Automazione Excel con Python che va oltre la modifica di base

Ogni mese porta lo stesso lavoro su Excel: scaricare i file delle vendite regionali, incollarli in una cartella di lavoro master, aggiornare i totali, segnalare qualcosa che sembra sbagliato, inviare il PDF via email e archiviare le copie del mese scorso. Niente di tutto ciò è difficile, ed è esattamente questo il problema — il lavoro è ripetitivo, soggetto a errori quando viene fatto a mano e cresce silenziosamente con l'aumentare del numero di file. L'automazione Excel con Python sostituisce questi passaggi manuali ricorrenti con script che leggono, aggiornano, uniscono, controllano e consegnano cartelle di lavoro secondo una pianificazione.

Questa guida mostra ciascuno di questi compiti implementato con Spire.XLS for Python 16.8.2 (il pacchetto Python indipendente su PyPI), da una modifica di cella in cinque righe a una pipeline pianificata che ricalcola le formule e consegna PDF. Ogni frammento riportato di seguito è stato eseguito e i relativi file di output sono stati aperti e verificati prima della pubblicazione. Lungo il percorso vengono anche indicati gli ambiti in cui si inseriscono le altre librerie comuni, così da vedere i compromessi invece di una brochure di prodotto.

Scelta di una libreria Python per l'automazione di Excel

L'automazione Excel con Python è adatta quando un'attività viene ripetuta secondo una pianificazione, segue regole fisse e riguarda file anziché giudizio: composizione di report mensili, controlli settimanali dei dati, aggiornamento di cifre in un modello, conversione di cartelle di lavoro per sistemi a valle. Se un'attività cambia forma ogni volta o richiede una decisione umana nel mezzo, automatizzarla costerà più di quanto faccia risparmiare. Una nota sui confini: questa guida riguarda l'elaborazione di file Excel. L'automazione della generazione di documenti da Excel a PowerPoint o da Excel a Word è un argomento correlato ma separato.

La scelta della libreria dipende dal lavoro. La tabella seguente riassume le cinque librerie che è più probabile incontrare; ciascuna ha una riga perché ciascuna ha una specialità.

pandas è difficile da battere per l'analisi che si adatta già a una tabella, openpyxl per le modifiche a livello di cella, XlsxWriter per scrivere nuove cartelle di lavoro, xlwings per pilotare Excel stesso. Ciascuna si concentra su una parte diversa del flusso di lavoro e combinarle significa dipendenze extra e lavoro di integrazione tra modelli a oggetti diversi. Spire.XLS offre un'unica API che copre lettura, modifica, calcolo, conversione e protezione nei formati supportati — gli esempi seguenti mantengono tutto in una sola.

Se stai confrontando le librerie in modo approfondito invece di cercare codice di implementazione, consulta il nostro confronto in migliore libreria Excel per Python.

Lettura e aggiornamento delle cartelle di lavoro Excel con Python

L'attività di automazione più comune è anche la più semplice: caricare una cartella di lavoro, modificare alcune celle, salvarla. Installa prima il pacchetto con pip install Spire.XLS, poi l'intero lavoro sta in poche righe:

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

Alcune convenzioni di lettura vale la pena conoscerle prima di costruirci sopra. Nell'API di Spire.XLS, Range[addr].NumberValue restituisce il valore numerico di una cella e NaN quando la cella contiene testo o nulla; Range[addr].Text restituisce la stringa visualizzata; e per le celle con formule, Range[addr].Formula restituisce la stringa della formula mentre FormulaNumberValue restituisce il risultato calcolato. Scrivere una formula tramite .Formula memorizza la formula stessa — per rendere persistente il suo risultato calcolato nel file, vedi la sezione sul ricalcolo più avanti in questa guida.

Nel nostro test di questo frammento, il valore aggiornato, la riga aggiunta, il suo formato numerico e la formattazione esistente dell'intestazione sono rimasti invariati dopo il salvataggio, e la formula è stata preservata esattamente come scritta. Riaprendo il file salvato con Spire.XLS e chiamando CalculateAllValue() è stato restituito 528,75 per la cella aggiunta =B6*C6, e una lettura indipendente tramite openpyxl ha confermato gli stessi valori nel file salvato.

Automazione di report Excel ed elaborazione in batch

Combinare cartelle di lavoro regionali in un unico report master

Combinare i file regionali in un'unica cartella di lavoro master è il punto in cui l'automazione inizia a ripagarsi. Con Spire.XLS, ogni file di origine viene caricato a turno, le sue righe vengono lette tramite l'intervallo allocato e i dati finiscono in una nuova cartella di lavoro con una colonna di origine, così ogni riga resta tracciabile:

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()

Nel nostro test con tre file di input, l'output unito conteneva esattamente la somma delle righe di input — nove in totale — la colonna delle entrate conteneva numeri reali (sommati davano 94.298,00, corrispondenti agli input al centesimo), la colonna di origine risolveva esattamente i tre nomi dei file e nessuna riga di intestazione è finita nei dati. Il risultato era rileggibile anche da openpyxl, quindi può alimentare direttamente il passo successivo di una pipeline. Un limite da notare: questo ciclo copia i valori delle celle, non la formattazione di origine. Se le colonne di origine contengono date, percentuali o importi in valuta reali di Excel, applica i formati numerici corrispondenti alle colonne di destinazione — nei nostri file di test la colonna Month è testo, quindi la copia è esatta.

Generazione di report formattati per cliente

L'unione ti fornisce un set di dati; la generazione di report lo trasforma in deliverable. Leggere una tabella master e produrre una cartella di lavoro di fattura formattata per cliente è un ciclo: raggruppa le righe, poi costruisci ogni fattura con un titolo unito, una riga di intestazione formattata, importi formattati come numeri e un totale 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()

Nel nostro test, tre clienti hanno prodotto tre cartelle di lavoro, il titolo unito e l'intestazione formattata sono stati mantenuti, e la formula =SUM è sopravvissuta al salvataggio. Una nota pratica: il nome del file deriva direttamente dal nome del cliente — se i nomi reali possono contenere caratteri come / o :, sanitizzali prima di costruire il nome del file. Dopo CalculateAllValue(), il totale della fattura Acme indicava 8.680,50 — corrispondente esattamente alle tre voci — e la stringa della formula era ancora nella cella, quindi Excel continua a ricalcolarla all'apertura. Per modelli complessi con grafici o tabelle pivot, il round-trip è il punto in cui viene testata la conservazione degli oggetti; questo è trattato nella sezione avanzata più avanti.

Convalida dei dati Excel ed evidenziazione delle eccezioni

L'automazione non riguarda solo la produzione di file; riguarda anche il loro controllo. Uno schema utile è un passo di scansione che percorre una cartella di lavoro, applica le tue regole di qualità dei dati e contrassegna le righe che non le rispettano, così una persona rivede le righe segnalate invece di rileggere tutto. Si tratta di controllo dei dati con marcatori visibili — non sostituisce la funzionalità Convalida dati di Excel, che controlla ciò che un utente può digitare in una cella. Con Spire.XLS, la scansione legge le celle tramite NumberValue, che restituisce NaN sia per il testo sia per le celle vuote — quindi la prima regola seguente segnala missing_or_non_numeric invece di pretendere di distinguere i due casi — e contrassegna le anomalie tramite gli stili delle celle:

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()

Nei nostri dati di test, questo ha correttamente segnalato le quattro righe problematiche — due con valori mancanti o non numerici, un valore anomalo di stipendio sopra la soglia, un bonus negativo — ha lasciato intatte le righe corrette e ha scritto un motivo per riga nella colonna D, che abbiamo verificato sia riaprendo il file sia nell'XML sottostante. Eseguendo di nuovo la scansione sulla cartella di lavoro di test invariata sono state prodotte le stesse quattro righe segnalate. Le regole qui sono volutamente semplici: per dati reali delle buste paga, le soglie e l'insieme di regole sono la parte interessante, e risiedono nel tuo codice dove possono essere versionati e revisionati.

Questo schema si combina bene con le sezioni precedenti: unisci i file regionali, analizza i dati combinati e instrada la cartella di lavoro alla revisione o alla consegna a seconda di ciò che rileva l'analisi.

Pianificazione dell'automazione Excel con Python

Uno script che deve essere eseguito a mano è solo metà di un'automazione. L'altra metà è farlo funzionare quando dovrebbe. Poiché i passaggi precedenti sono puro Python, il flusso di lavoro finito — carica, unisci, analizza, genera, consegna — si racchiude in un'unica funzione che un pianificatore del sistema operativo può eseguire da solo:

Entrambi avviano lo script, lo lasciano fare il suo lavoro ed escono — nessun processo a lunga esecuzione da sorvegliare. Il loro comportamento in caso di esecuzione mancata è però diverso: l'Utilità di pianificazione di Windows può essere configurata per eseguire un'attività il prima possibile dopo che l'avvio pianificato è stato perso, mentre i normali job cron generalmente non recuperano le esecuzioni perse mentre il sistema era offline. Una nota di distribuzione che evita confusione in seguito: Spire.XLS elabora direttamente i file delle cartelle di lavoro e non richiede Excel desktop installato, quindi gli script precedenti funzionano su un server Linux o in un container — sostituendo il vecchio approccio di scripting di Office desktop tramite automazione COM. Non aver bisogno di Excel, però, non equivale a riprodurre tutti i comportamenti di Excel; la sezione successiva riguarda le parti che sono davvero difficili da riprodurre.

Gestione delle attività avanzate di automazione Excel

Per molte pipeline, le sezioni precedenti sono la risposta completa. Alcuni flussi di lavoro continuano ad aggiungere requisiti — più formati di input, formule che devono essere ricalcolate, consegna PDF, archivi protetti. Questa sezione esamina questi punti con codice testato con Spire.XLS for Python 16.8.2 (il pacchetto Python indipendente su PyPI). È un percorso implementativo per i requisiti più difficili, non la risposta predefinita a ogni attività di questa pagina.

Lavorare con più formati di file

È comune che un sistema a monte esporti .xls, .xlsb o .ods mentre la tua pipeline si aspetta .xlsx. Ogni formato di solito implica un pacchetto Python e un motore diversi. Spire.XLS li gestisce tramite la stessa API della cartella di lavoro — e nei nostri test con 16.8.2, lo stesso oggetto cartella di lavoro ha caricato e salvato .xls, .ods, .xlsx e .xlsb (FileFormat.Xlsb2007 / Xlsb2010), e ha eseguito il round-trip di .xls, .ods e .xlsb nei rispettivi formati con i valori intatti. I file .xlsb che abbiamo scritto si sono anche riaperti in Excel senza problemi, sebbene il parser open source pyxlsb non sia riuscito a leggerli — vale la pena verificarlo con i tuoi lettori a valle prima di adottarlo.

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 distinzione da tenere presente: «modificare e salvare nel formato originale» e «convertire per la consegna» sono obiettivi diversi. Il primo mantiene un file di lavoro sul posto; il secondo alimenta un consumatore a valle. Entrambi compaiono nell'esempio end-to-end riportato di seguito.

Ricalcolo delle formule

Le librerie che scrivono formule non scrivono necessariamente i risultati. openpyxl, per esempio, conserva la stringa di una formula ma non memorizza alcun valore calcolato, quindi un lettore a valle che non calcola non vede nulla — un problema reale quando una pipeline pianificata consegna file a sistemi che leggono il file così com'è.

Un motore di calcolo colma questa lacuna:

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()

Abbiamo verificato entrambi gli aspetti. Al caricamento, Spire.XLS calcola già in memoria per impostazione predefinita (RecalculateOnOpen è attivo), quindi FormulaNumberValue legge subito i numeri calcolati — ma rendere persistenti i risultati nel file richiede la chiamata esplicita a CalculateAllValue() prima del salvataggio. Con la chiamata, il file salvato conteneva i valori calcolati, cosa che il nostro lettore openpyxl con data_only=True ha confermato; senza, le stesse celle leggevano None. Dopo quel salvataggio, qualsiasi libreria può leggere i risultati. Un limite da precisare: il calcolo copre le funzioni e le dipendenze supportate dal motore — le cartelle di lavoro che si basano su collegamenti esterni, funzioni dei componenti aggiuntivi o funzioni al di fuori dell'insieme supportato dovrebbero essere testate con i tuoi file prima di dipendere dall'output calcolato.

Esportazione di report Excel in PDF

I report pianificati di solito finiscono come PDF per persone che non aprono mai la cartella di lavoro. Renderizzare un foglio di calcolo in modo fedele — larghezze delle colonne, caratteri, grafici — è esattamente la parte in cui gli strumenti di conversione generici sbagliano. Con Spire.XLS il foglio di lavoro si renderizza da solo, con l'impostazione di pagina definita prima:

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()

Le impostazioni FitToPagesWide e FitToPagesTall ridimensionano il foglio di lavoro per adattarlo a una pagina in larghezza e una in altezza, il che impedisce che le colonne si dividano tra le pagine — su fogli molto larghi, però, il testo ridotto può diventare troppo piccolo per essere letto comodamente. Il SaveToPdf a livello di foglio di lavoro consegna esattamente il foglio scelto anziché ogni foglio della cartella di lavoro. Nel nostro test, il PDF esportato è risultato una singola pagina con il titolo, la tabella completa inclusi i totali ricalcolati e il grafico renderizzato. Per i dettagli sul layout, vedi conversione di Excel in PDF in Python.

Lavorare con grafici e tabelle pivot

Le cartelle di lavoro dei report di solito contengono oggetti, non solo celle. Nella nostra cartella di lavoro di test, un round-trip tramite Spire.XLS 16.8.2 ha mantenuto intatte le parti del grafico a livello XML, e il grafico è stato renderizzato completamente quando il file è stato riaperto in Excel. Lo affermiamo come risultato per i nostri file di test, non come garanzia per ogni oggetto DrawingML — le forme complesse dovrebbero essere verificate con i tuoi file, lo stesso consiglio valido per qualsiasi libreria. L'API della cartella di lavoro di Spire.XLS copre anche tabelle pivot e grafici pivot — creazione, aggiornamento e operazioni sui campi; per il lato tabelle pivot, vedi creare o gestire tabelle pivot in Excel. Il nostro file di test non includeva una tabella pivot, quindi esegui il round-trip sui tuoi fogli di lavoro prima di adottarlo.

Protezione delle cartelle di lavoro Excel

I report archiviati o inviati via email spesso richiedono una password di apertura. Una sola chiamata la imposta:

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

Nel nostro test, il file non si apriva senza la password — anche in openpyxl, che ha generato un errore sul contenitore crittografato. Rileggerlo tramite la stessa libreria richiede la proprietà OpenPassword. Quindi, se una pipeline sia protegge sia legge successivamente file protetti, il lato lettura della toolchain deve supportarlo.

Scelta di una libreria per l'automazione Excel in produzione

Oltre alla copertura delle API, una dipendenza di produzione necessita anche di un piano di manutenzione. Spire.XLS for Python continua a pubblicare versioni — 16.8.2 (agosto 2026, la release testata in tutta questa guida) ha aggiunto, per esempio, il supporto alla formula TEXTSPLIT. La licenza è perpetua: la licenza copre l'uso continuativo secondo i suoi termini, mentre l'accesso alle nuove release segue il diritto agli aggiornamenti — un anno di aggiornamenti del prodotto e hotfix è incluso nei piani di licenza, e il supporto commerciale ti offre un canale del fornitore definito per problemi di formato, calcolo o conversione invece di un tracker della community. Gli obiettivi di tempo di risposta, i canali di supporto e gli extra per piano variano in base al livello — vedi la pagina piani di licenza di Spire.XLS for Python, o il confronto migliore libreria Excel per Python per capire come il numero di sviluppatori e l'ambito di distribuzione si adattano alla scelta.

Un esempio end-to-end

I componenti precedenti si combinano in un unico flusso di lavoro di conversione e consegna: leggi un input legacy .xlsb, aggiorna un valore, ricalcola e consegna sia un PDF sia un file .xlsx protetto da password:

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

Ogni passaggio è stato verificato nel nostro ambiente di test usando Spire.XLS for Python 16.8.2 e Python 3.13. Se questo flusso di lavoro corrisponde ai tuoi requisiti, esplora Spire.XLS for Python. L'edizione gratuita è sufficiente per una valutazione di base; per progetti commerciali, richiedi una licenza temporanea di un mese e testa l'API completa con le tue cartelle di lavoro prima di scegliere una licenza di produzione (controlla la pagina ufficiale per i termini correnti).

Domande frequenti

Python può automatizzare Excel senza Excel installato?

Sì, per l'elaborazione dei file — Spire.XLS legge e scrive direttamente i file delle cartelle di lavoro e nessuno degli esempi qui riportati ha richiesto Excel desktop. L'eccezione è xlwings Classic, che pilota l'applicazione Excel in esecuzione. «Nessun Excel necessario» riguarda l'esecuzione del codice, non la riproduzione di ogni comportamento di Excel.

Qual è la migliore libreria Python per l'automazione di Excel?

Dipende dal lavoro: pandas per l'analisi, openpyxl per modifiche a livello di cella di file .xlsx, XlsxWriter per nuove cartelle di lavoro formattate, xlwings per pilotare Excel stesso. Per un'unica API che copra lettura, modifica, calcolo, conversione e protezione, consulta il nostro confronto migliore libreria Excel per Python.

openpyxl può ricalcolare le formule di Excel?

No — conserva le stringhe delle formule ma non ha un motore di calcolo, e le formule scritte da openpyxl non contengono risultati memorizzati nella cache; data_only=True legge solo le cache archiviate nel file, quindi per quelle celle legge None. Per calcolare e rendere persistenti i risultati, vedi aggiungere o leggere formule in Excel.

Come posso pianificare uno script Python per Excel?

Usa l'Utilità di pianificazione di Windows o cron per fare in modo che il sistema operativo avvii lo script — nota che l'Utilità di pianificazione può essere impostata per rieseguire le attività perse, mentre cron standard non recupera le esecuzioni perse mentre la macchina era offline. Poiché lo script elabora direttamente i file delle cartelle di lavoro, non è necessario Excel desktop sulla macchina che lo esegue.

Come posso convertire Excel in PDF con Python?

Imposta le impostazioni di pagina (orientamento, adatta alla pagina) ed esporta direttamente il foglio di lavoro con una libreria che genera PDF da sola. Il percorso open source richiede una libreria di conversione separata in cui gestisci il layout. Dettagli in conversione di Excel in PDF in Python.

Conclusione

L'automazione Excel con Python spazia da una modifica di cella in cinque righe a una pipeline pianificata che unisce file, segnala dati errati, ricalcola formule e consegna PDF e cartelle di lavoro protette. pandas, openpyxl e le librerie simili restano scelte valide per l'analisi e le modifiche a singola attività. Quando il lavoro diventa un flusso di lavoro — più formati in ingresso, risultati calcolati in uscita, PDF e archivi protetti consegnati secondo una pianificazione — un'API unificata per cartelle di lavoro con una release mantenuta e un canale di supporto è ciò che la sostiene in produzione, ed è ciò che hanno dimostrato gli esempi di Spire.XLS for Python in questa guida.