Automatisation Excel avec Python : au-delà de l’édition de base

Chaque mois apporte le même travail Excel : télécharger les fichiers de ventes régionaux, les coller dans un classeur maître, actualiser les totaux, signaler tout ce qui semble anormal, envoyer le PDF par e-mail et archiver les copies du mois dernier. Rien de tout cela n'est difficile, et c'est précisément le problème : le travail est répétitif, sujet aux erreurs lorsqu'il est fait à la main, et il s'accroît discrètement à mesure que le nombre de fichiers augmente. L'automatisation Excel avec Python remplace ces étapes manuelles récurrentes par des scripts qui lisent, mettent à jour, fusionnent, vérifient et livrent des classeurs selon un calendrier.

Ce guide montre chacune de ces tâches implémentée avec Spire.XLS for Python 16.8.2 (le package Python indépendant sur PyPI), de la modification d'une cellule en cinq lignes à un pipeline planifié qui recalcule les formules et livre des PDF. Chaque extrait de code ci-dessous a été exécuté, et ses fichiers de sortie ont été ouverts et vérifiés avant publication. Il indique également, au passage, où se situent les autres bibliothèques courantes, afin que vous puissiez voir les compromis plutôt qu'une brochure commerciale.

Choisir une bibliothèque Python pour l'automatisation d'Excel

L'automatisation Excel avec Python est bien adaptée lorsqu'une tâche est répétée selon un calendrier, suit des règles fixes et implique des fichiers plutôt qu'un jugement : assemblage de rapports mensuels, contrôles de données hebdomadaires, mise à jour de chiffres dans un modèle, conversion de classeurs pour des systèmes en aval. Si une tâche change de forme à chaque fois ou nécessite une décision humaine en cours de route, la scripter coûtera plus qu'elle ne rapporte. Une remarque sur les limites : ce guide couvre le traitement de fichiers Excel. L'automatisation de la génération de documents Excel vers PowerPoint ou Excel vers Word est un sujet connexe mais distinct.

Le choix de la bibliothèque dépend de la tâche. Le tableau ci-dessous résume les cinq bibliothèques que vous êtes le plus susceptible de rencontrer ; chacune n'a qu'une ligne car chacune a sa spécialité.

pandas est difficile à battre pour une analyse qui tient déjà dans un tableau, openpyxl pour les modifications au niveau des cellules, XlsxWriter pour écrire de nouveaux classeurs, xlwings pour piloter Excel lui-même. Chacune se concentre sur une partie différente du flux de travail, et les combiner implique des dépendances supplémentaires et un travail d'intégration entre des modèles objets différents. Spire.XLS offre une API unique couvrant la lecture, la modification, le calcul, la conversion et la protection sur les formats pris en charge — les exemples ci-dessous gardent tout dans un seul outil.

Si vous comparez les bibliothèques en profondeur plutôt que de chercher du code d'implémentation, consultez notre comparaison dans meilleure bibliothèque Excel pour Python.

Lire et mettre à jour des classeurs Excel avec Python

La tâche d'automatisation la plus courante est aussi la plus simple : charger un classeur, modifier quelques cellules, l'enregistrer. Installez d'abord le package avec pip install Spire.XLS, puis tout le travail tient en quelques lignes :

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

Quelques conventions de lecture méritent d'être connues avant d'aller plus loin. Dans l'API de Spire.XLS, Range[addr].NumberValue renvoie la valeur numérique d'une cellule et NaN lorsque la cellule contient du texte ou rien ; Range[addr].Text renvoie la chaîne affichée ; et pour les cellules de formule, Range[addr].Formula renvoie la chaîne de formule tandis que FormulaNumberValue renvoie le résultat calculé. Écrire une formule via .Formula stocke la formule elle-même — pour conserver son résultat calculé dans le fichier, consultez la section sur le recalcul plus loin dans ce guide.

Lors de notre test de cet extrait, la valeur mise à jour, la ligne ajoutée, son format numérique et le style d'en-tête existant ont tous survécu à l'enregistrement, et la formule a été préservée exactement telle qu'écrite. La réouverture du fichier enregistré avec Spire.XLS et l'appel à CalculateAllValue() ont renvoyé 528,75 pour la cellule =B6*C6 ajoutée, et une lecture indépendante via openpyxl a confirmé les mêmes valeurs dans le fichier enregistré.

Automatiser des rapports Excel et le traitement par lots

Combiner des classeurs régionaux en un rapport maître

Combiner les fichiers régionaux en un classeur maître est là où l'automatisation commence à être rentable. Avec Spire.XLS, chaque fichier source est chargé tour à tour, ses lignes sont lues via la plage allouée, et les données arrivent dans un nouveau classeur avec une colonne source afin que chaque ligne reste traçable :

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

Lors de notre test avec trois fichiers d'entrée, la sortie fusionnée contenait exactement la somme des lignes d'entrée — neuf au total — la colonne des revenus contenait de vrais nombres (ils totalisaient 94 298,00, correspondant aux entrées au centime près), la colonne source correspondait exactement aux trois noms de fichiers, et aucune ligne d'en-tête ne s'est glissée dans les données. Le résultat était également relisible par openpyxl, il peut donc alimenter directement l'étape suivante d'un pipeline. Une limite à noter : cette boucle copie les valeurs des cellules, pas la mise en forme source. Si vos colonnes sources contiennent de vraies dates Excel, des pourcentages ou des montants en devise, appliquez les formats numériques correspondants aux colonnes de destination — dans nos jeux de test, la colonne Month est du texte, la copie est donc exacte.

Générer des rapports formatés par client

La fusion vous donne un jeu de données ; la génération de rapports le transforme en livrables. Lire un tableau maître et produire un classeur de facture formaté par client est une boucle : regrouper les lignes, puis construire chaque facture avec un titre fusionné, une ligne d'en-tête stylée, des montants au format numérique et un total 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()

Lors de notre test, trois clients ont produit trois classeurs, le titre fusionné et l'en-tête stylé ont été conservés, et la formule =SUM a survécu à l'enregistrement. Une remarque pratique : le nom du fichier provient directement du nom du client — si de vrais noms peuvent contenir des caractères tels que / ou :, nettoyez-les avant de construire le nom du fichier. Après CalculateAllValue(), le total de la facture Acme affichait 8 680,50 — correspondant exactement aux trois lignes d'articles — et la chaîne de formule était toujours dans la cellule, Excel continue donc de la recalculer à l'ouverture. Pour les modèles complexes avec graphiques ou tableaux croisés dynamiques, l'aller-retour est l'endroit où la préservation des objets est mise à l'épreuve ; cela est traité dans la section avancée ci-dessous.

Valider les données Excel et signaler les exceptions

L'automatisation ne consiste pas seulement à produire des fichiers ; il s'agit aussi de les vérifier. Un modèle utile est une étape d'analyse qui parcourt un classeur, applique vos règles de qualité des données et marque les lignes qui y échouent afin qu'une personne examine les lignes signalées plutôt que de tout relire. Il s'agit d'un contrôle des données avec des marqueurs visibles — cela ne remplace pas la fonctionnalité Validation des données d'Excel, qui contrôle ce qu'un utilisateur peut saisir dans une cellule. Avec Spire.XLS, l'analyse lit les cellules via NumberValue, qui renvoie NaN à la fois pour le texte et les cellules vides — la première règle ci-dessous signale donc missing_or_non_numeric plutôt que de prétendre distinguer les deux cas — et marque les échecs via les styles de cellule :

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

Dans nos données de test, cela a correctement signalé les quatre lignes problématiques — deux avec des valeurs manquantes ou non numériques, un salaire aberrant au-dessus du seuil, un bonus négatif — a laissé les lignes valides intactes et a écrit une raison par ligne dans la colonne D, ce que nous avons vérifié à la fois en réouvrant le fichier et dans le XML sous-jacent. Une nouvelle exécution de l'analyse sur le classeur de test inchangé a produit les mêmes quatre lignes signalées. Les règles ici sont volontairement simples : pour de vraies données de paie, les seuils et l'ensemble des règles sont la partie intéressante, et ils résident dans votre code où ils peuvent être versionnés et revus.

Ce modèle se combine bien avec les sections précédentes : fusionnez les fichiers régionaux, analysez les données combinées, et acheminez le classeur vers la revue ou la livraison selon ce que l'analyse révèle.

Planifier l'automatisation Excel avec Python

Un script qui doit être exécuté à la main n'est qu'une demi-automatisation. L'autre moitié consiste à le faire s'exécuter quand il le faut. Étant donné que les étapes ci-dessus sont du Python pur, le flux de travail terminé — charger, fusionner, analyser, générer, livrer — se regroupe dans une fonction qu'un planificateur du système d'exploitation peut exécuter seul :

Les deux lancent votre script, le laissent faire son travail et se terminent — aucun processus de longue durée à surveiller. Leur comportement en cas d'exécution manquée diffère toutefois : le Planificateur de tâches Windows peut être configuré pour exécuter une tâche dès que possible après que son démarrage planifié a été manqué, tandis que les tâches cron standard ne rattrapent généralement pas les exécutions manquées lorsque le système était hors ligne. Une remarque de déploiement qui évitera des confusions plus tard : Spire.XLS traite directement les fichiers de classeur et n'a pas besoin d'Excel de bureau installé, les scripts ci-dessus fonctionnent donc sur un serveur Linux ou dans un conteneur — remplaçant l'approche plus ancienne consistant à scripter Office de bureau via l'automatisation COM. Ne pas avoir besoin d'Excel n'équivaut pas toutefois à reproduire tout le comportement d'Excel ; la section suivante traite des parties réellement difficiles à reproduire.

Gérer les tâches avancées d'automatisation Excel

Pour de nombreux pipelines, les sections ci-dessus constituent la réponse finale. Certains flux de travail continuent d'ajouter des exigences — davantage de formats d'entrée, des formules à recalculer, une livraison en PDF, des archives protégées. Cette section parcourt ces points avec du code testé avec Spire.XLS for Python 16.8.2 (le package Python indépendant sur PyPI). C'est une piste d'implémentation pour les exigences les plus difficiles, pas la réponse par défaut à chaque tâche de cette page.

Travailler avec plusieurs formats de fichiers

Il est courant qu'un système en amont exporte en .xls, .xlsb ou .ods alors que votre pipeline attend du .xlsx. Chaque format implique généralement un package et un moteur Python différents. Spire.XLS les gère via la même API de classeur — et dans nos tests avec la 16.8.2, le même objet classeur a chargé et enregistré .xls, .ods, .xlsx et .xlsb (FileFormat.Xlsb2007 / Xlsb2010), et a fait des allers-retours sur .xls, .ods et .xlsb vers leurs propres formats avec des valeurs intactes. Les fichiers .xlsb que nous avons écrits se sont également réouverts dans Excel sans problème, bien que l'analyseur open source pyxlsb n'ait pas pu les lire — à vérifier avec vos propres lecteurs en aval avant de vous engager.

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

Une distinction à garder à l'esprit : « modifier et enregistrer dans le format d'origine » et « convertir pour livraison » sont des objectifs différents. La première conserve un fichier de travail en place ; la seconde alimente un consommateur en aval. Les deux apparaissent dans l'exemple de bout en bout ci-dessous.

Recalculer les formules

Les bibliothèques qui écrivent des formules n'écrivent pas nécessairement de résultats. openpyxl, par exemple, préserve une chaîne de formule mais ne stocke aucune valeur calculée, un lecteur en aval qui ne calcule pas ne voit donc rien — un vrai problème lorsqu'un pipeline planifié livre des fichiers à des systèmes qui lisent le fichier tel quel.

Un moteur de calcul comble cette lacune :

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

Nous avons vérifié les deux côtés. Au chargement, Spire.XLS calcule déjà en mémoire par défaut (RecalculateOnOpen est activé), FormulaNumberValue lit donc immédiatement des nombres calculés — mais conserver les résultats dans le fichier nécessite l'appel explicite à CalculateAllValue() avant l'enregistrement. Avec cet appel, le fichier enregistré contenait les valeurs calculées, ce que notre lecteur openpyxl avec data_only=True a confirmé ; sans lui, les mêmes cellules lisaient None. Après cet enregistrement, n'importe quelle bibliothèque peut lire les résultats. Une limite à préciser : le calcul couvre les fonctions et dépendances prises en charge par le moteur — les classeurs qui s'appuient sur des liens externes, des fonctions de complément ou des fonctions hors de l'ensemble pris en charge doivent être testés avec vos propres fichiers avant de dépendre de la sortie calculée.

Exporter des rapports Excel en PDF

Les rapports planifiés finissent généralement en PDF pour des personnes qui n'ouvrent jamais le classeur. Rendre une feuille de calcul fidèlement — largeurs de colonnes, polices, graphiques — est exactement la partie que les outils de conversion génériques ratent. Avec Spire.XLS, la feuille de calcul se rend elle-même, avec la mise en page définie au préalable :

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

Les paramètres FitToPagesWide et FitToPagesTall mettent la feuille de calcul à l'échelle pour qu'elle tienne sur une page en largeur et une page en hauteur, ce qui évite que les colonnes ne se répartissent sur plusieurs pages — sur des feuilles très larges, toutefois, le texte réduit peut devenir trop petit pour être lu confortablement. Le SaveToPdf au niveau de la feuille de calcul livre exactement la feuille que vous choisissez plutôt que toutes les feuilles du classeur. Dans notre test, le PDF exporté est sorti sur une seule page avec le titre, le tableau complet incluant les totaux recalculés, et le graphique rendu. Pour les détails de mise en page, consultez convertir Excel en PDF avec Python.

Travailler avec des graphiques et des tableaux croisés dynamiques

Les classeurs de rapport contiennent généralement des objets, pas seulement des cellules. Dans notre classeur de test, un aller-retour via Spire.XLS 16.8.2 a conservé les parties de graphique intactes au niveau XML, et le graphique s'est rendu complètement à la réouverture du fichier dans Excel. Nous l'affirmons comme un résultat pour nos jeux de test, non comme une garantie pour chaque objet DrawingML — les formes complexes doivent être vérifiées avec vos propres fichiers, le même conseil qui s'applique à toute bibliothèque. L'API de classeur de Spire.XLS couvre également les tableaux croisés dynamiques et les graphiques croisés dynamiques — création, actualisation et opérations sur les champs ; pour le volet tableau croisé dynamique, consultez créer ou manipuler des tableaux croisés dynamiques dans Excel. Notre jeu de test n'incluait pas de tableau croisé dynamique, faites donc passer vos propres classeurs par l'aller-retour avant de vous engager.

Protéger des classeurs Excel

Les rapports archivés ou envoyés par e-mail nécessitent souvent un mot de passe d'ouverture. Un seul appel le définit :

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

Dans notre test, le fichier ne s'ouvrait pas sans le mot de passe — y compris dans openpyxl, qui a levé une erreur sur le conteneur chiffré. Le relire via la même bibliothèque nécessite la propriété OpenPassword. Donc si un pipeline protège puis lit ultérieurement des fichiers protégés, le côté lecteur de la chaîne d'outils doit le prendre en charge.

Choisir une bibliothèque pour l'automatisation Excel en production

Au-delà de la couverture de l'API, une dépendance de production nécessite aussi un plan de maintenance. Spire.XLS for Python continue de publier — la 16.8.2 (août 2026, la version testée tout au long de ce guide) a ajouté la prise en charge de la formule TEXTSPLIT, par exemple. La licence est perpétuelle : la licence couvre l'utilisation continue selon ses termes, tandis que l'accès aux nouvelles versions suit le droit aux mises à jour — un an de mises à jour de produit et de correctifs est inclus avec les offres de licence, et le support commercial vous donne un canal fournisseur défini pour les problèmes de format, de calcul ou de conversion au lieu d'un tracker communautaire. Les objectifs de délai de réponse, les canaux de support et les extras par offre varient selon le niveau — consultez la page des offres de licence Spire.XLS for Python, ou la comparaison meilleure bibliothèque Excel pour Python pour voir comment le nombre de développeurs et la portée du déploiement influencent le choix.

Un exemple de bout en bout

Les éléments ci-dessus se combinent en un seul flux de travail de conversion-livraison : lire une entrée .xlsb héritée, mettre à jour un chiffre, recalculer, et livrer à la fois un PDF et un .xlsx protégé par mot de passe :

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

Chaque étape a été vérifiée dans notre environnement de test avec Spire.XLS for Python 16.8.2 et Python 3.13. Si ce flux de travail correspond à vos besoins, découvrez Spire.XLS for Python. L'édition gratuite suffit pour une évaluation de base ; pour les projets commerciaux, demandez une licence temporaire d'un mois et testez l'API complète avec vos propres classeurs avant de choisir une licence de production (consultez la page officielle pour les conditions actuelles).

Questions fréquentes

Python peut-il automatiser Excel sans qu'Excel soit installé ?

Oui, pour le traitement de fichiers — Spire.XLS lit et écrit directement les fichiers de classeur, et aucun des exemples ici n'a nécessité Excel de bureau. L'exception est xlwings Classic, qui pilote l'application Excel active. « Sans Excel » concerne l'exécution du code, pas la reproduction de chaque comportement d'Excel.

Quelle bibliothèque Python est la meilleure pour l'automatisation d'Excel ?

Cela dépend de la tâche : pandas pour l'analyse, openpyxl pour les modifications de .xlsx au niveau des cellules, XlsxWriter pour les nouveaux classeurs formatés, xlwings pour piloter Excel lui-même. Pour une API unique couvrant la lecture, la modification, le calcul, la conversion et la protection, consultez notre comparaison meilleure bibliothèque Excel pour Python.

openpyxl peut-il recalculer des formules Excel ?

Non — il préserve les chaînes de formule mais n'a pas de moteur de calcul, et les formules écrites par openpyxl ne portent aucun résultat mis en cache ; data_only=True ne lit que les caches stockés dans le fichier, il lit donc None pour ces cellules. Pour calculer et conserver les résultats, consultez ajouter ou lire des formules dans Excel.

Comment planifier un script Python pour Excel ?

Utilisez le Planificateur de tâches Windows ou cron pour laisser le système d'exploitation lancer le script — notez que le Planificateur de tâches peut être configuré pour relancer les tâches manquées, tandis que cron standard ne rattrape pas les exécutions manquées lorsque la machine était hors ligne. Étant donné que le script traite directement les fichiers de classeur, aucun Excel de bureau n'est nécessaire sur la machine qui l'exécute.

Comment convertir Excel en PDF avec Python ?

Définissez la mise en page (orientation, ajustement à la page) et exportez directement la feuille de calcul avec une bibliothèque qui rend elle-même les PDF. La voie open source nécessite une bibliothèque de conversion séparée où vous gérez la mise en page. Détails dans convertir Excel en PDF avec Python.

Conclusion

L'automatisation Excel avec Python couvre tout, de la modification d'une cellule en cinq lignes à un pipeline planifié qui fusionne des fichiers, signale les données erronées, recalcule les formules et livre des PDF et des classeurs protégés. pandas, openpyxl et leurs voisines restent d'excellents choix pour l'analyse et les modifications à tâche unique. Lorsque la tâche devient un flux de travail — plusieurs formats en entrée, des résultats calculés en sortie, des PDF et des archives protégées livrés selon un calendrier — une API de classeur unifiée avec une version maintenue et un canal de support est ce qui la porte en production, et c'est ce que les exemples Spire.XLS for Python de ce guide ont démontré.