Table des matières
La création de fichiers Excel en Python est une exigence courante dans les applications basées sur les données. Lorsque les données d'application doivent être livrées dans un format que les utilisateurs professionnels peuvent facilement examiner et partager, Excel reste l'un des choix les plus pratiques et les plus largement acceptés.
Dans les projets réels, la génération d'un fichier Excel avec Python est souvent le point de départ d'un processus automatisé. Les données peuvent provenir de bases de données, d'API ou de services internes, et Python est chargé de transformer ces données en un fichier Excel structuré qui suit une mise en page et une convention de nommage cohérentes.
Cet article montre comment créer des fichiers Excel en Python, de la génération d'un classeur à partir de zéro à l'écriture de données, en passant par l'application d'une mise en forme de base et la mise à jour de fichiers existants si nécessaire. Tous les exemples sont présentés d'un point de vue pratique, en se concentrant sur la manière dont les fichiers Excel sont créés et utilisés dans des scénarios d'automatisation réels.
Table des matières
- Scénarios typiques de création de fichiers Excel en Python
- Configuration de l'environnement
- Création d'un nouveau fichier Excel à partir de zéro en Python
- Écriture de données structurées dans un fichier XLSX à l'aide de Python
- Mise en forme des données Excel pour des rapports réels en Python
- Lecture et mise à jour de fichiers Excel existants en Python
- Combinaison des opérations de lecture et d'écriture dans un seul flux de travail
- Choisir la bonne approche Python pour la création de fichiers Excel
- Problèmes courants et solutions
- Foire aux questions
1. Scénarios typiques de création de fichiers Excel avec Python
La création de fichiers Excel avec Python se fait généralement dans le cadre d'un système plus vaste plutôt que comme une tâche autonome. Les scénarios courants incluent :
- Génération de rapports d'activité quotidiens, hebdomadaires ou mensuels
- Exportation des résultats de requêtes de base de données pour analyse ou audit
- Production de fichiers Excel à partir de services backend ou de tâches par lots
- Automatisation de l'échange de données entre des systèmes internes ou des partenaires externes
Dans ces situations, Python est souvent utilisé pour générer automatiquement des fichiers Excel, aidant les équipes à réduire l'effort manuel tout en garantissant la cohérence et la répétabilité des données.
2. Configuration de l'environnement : Préparation à la création de fichiers Excel en Python
Dans ce tutoriel, nous utilisons Free Spire.XLS for Python pour démontrer les opérations sur les fichiers Excel. Avant de générer des fichiers Excel avec Python, assurez-vous que l'environnement de développement est prêt.
Version de Python
Toute version moderne de Python 3.x est suffisante pour les tâches d'automatisation d'Excel.
Free Spire.XLS for Python peut être installé via pip :
pip install spire.xls.freeVous pouvez également télécharger Free Spire.XLS for Python et l'inclure manuellement dans votre projet.
La bibliothèque fonctionne indépendamment de Microsoft Excel, ce qui la rend adaptée aux environnements de serveur, aux tâches planifiées et aux flux de travail automatisés où Excel n'est pas installé.
3. Création d'un nouveau fichier Excel à partir de zéro en Python
Cette section se concentre sur la création d'un fichier Excel à partir de zéro à l'aide de Python. L'objectif est de définir une structure de classeur de base, y compris les feuilles de calcul et les lignes d'en-tête, avant que des données ne soient écrites.
En générant la mise en page initiale par programme, vous pouvez vous assurer que tous les fichiers de sortie partagent la même structure et sont prêts pour une population de données ultérieure.
Exemple : Création d'un modèle Excel vierge
from spire.xls import Workbook, FileFormat
# Initialize a new workbook
workbook = Workbook()
# Access the default worksheet
sheet = workbook.Worksheets[0]
sheet.Name = "Template"
# Add a placeholder title
sheet.Range["B2"].Text = "Monthly Report Template"
# Save the Excel file
workbook.SaveToFile("template.xlsx", FileFormat.Version2016)
workbook.Dispose()
L'aperçu du fichier modèle :
Dans cet exemple :
- Workbook() crée un nouveau classeur Excel qui contient déjà trois feuilles de calcul par défaut.
- La première feuille de calcul est accessible via Worksheets[0] et renommée pour définir la structure de base.
- La propriété Range[].Text écrit du texte dans une cellule spécifique, vous permettant de définir des titres ou des espaces réservés avant que les données réelles ne soient ajoutées.
- La méthode SaveToFile() enregistre le classeur dans un fichier Excel. Et FileFormat.Version2016 spécifie la version ou le format Excel à utiliser.
Création de fichiers Excel avec plusieurs feuilles de calcul en Python
Dans la génération d'Excel basée sur Python, un seul classeur peut contenir plusieurs feuilles de calcul pour organiser logiquement les données associées. Chaque feuille de calcul peut stocker un ensemble de données, un résumé ou un résultat de traitement différent dans le même fichier.
L'exemple suivant montre comment créer un fichier Excel avec plusieurs feuilles de calcul et écrire des données dans chacune d'elles.
from spire.xls import Workbook, FileFormat
workbook = Workbook()
# Default worksheet
data_sheet = workbook.Worksheets[0]
data_sheet.Name = "Raw Data"
# Remove the second default worksheet
workbook.Worksheets.RemoveAt(1)
# Add a summary worksheet
summary_sheet = workbook.Worksheets.Add("Summary")
summary_sheet.Range["A1"].Text = "Summary Report"
workbook.SaveToFile("multi_sheet_report.xlsx", FileFormat.Version2016)
workbook.Dispose()
Ce modèle est couramment combiné avec des flux de travail de lecture/écriture, où les données brutes sont importées dans une feuille de calcul et les résultats traités sont écrits dans une autre.
Formats de fichiers Excel dans l'automatisation Python
Lors de la création de fichiers Excel par programme en Python, XLSX est le format le plus couramment utilisé et est entièrement pris en charge par les versions modernes de Microsoft Excel. Il prend en charge les feuilles de calcul, les formules, les styles et convient à la plupart des scénarios d'automatisation.
En plus de XLSX, Spire.XLS for Python prend en charge la génération de plusieurs formats Excel courants, notamment :
- XLSX – le format par défaut pour l'automatisation Excel moderne
- XLS – format Excel hérité pour la compatibilité avec les anciens systèmes
- CSV – format de texte brut souvent utilisé pour l'échange et l'importation de données
Dans cet article, tous les exemples utilisent le format XLSX, qui est recommandé pour la génération de rapports, les exportations de données structurées et les fichiers Excel basés sur des modèles. Vous pouvez consulter l'énumération FileFormat pour une liste complète des formats pris en charge.
4. Écriture de données structurées dans un fichier XLSX à l'aide de Python
Dans les applications réelles, les données écrites dans Excel proviennent rarement de listes codées en dur. Elles sont plus couramment générées à partir de requêtes de base de données, de réponses d'API ou de résultats de traitement intermédiaires.
Un modèle typique consiste à traiter Excel comme le format de livraison final pour des données déjà structurées.
Exemple Python : Génération d'un rapport de ventes mensuel à partir des données de l'application
Supposons que votre application a déjà produit une liste d'enregistrements de ventes, où chaque enregistrement contient des informations sur le produit et des totaux calculés. Dans cet exemple, les données de vente sont représentées sous forme de liste de dictionnaires, simulant des enregistrements renvoyés par une application ou une couche de service.
from spire.xls import Workbook
workbook = Workbook()
sheet = workbook.Worksheets[0]
sheet.Name = "Sales Report"
headers = ["Product", "Quantity", "Unit Price", "Total Amount"]
for col, header in enumerate(headers, start=1):
sheet.Range[1, col].Text = header
# Data typically comes from a database or service layer
sales_data = [
{"product": "Laptop", "qty": 15, "price": 1200},
{"product": "Monitor", "qty": 30, "price": 250},
{"product": "Keyboard", "qty": 50, "price": 40},
{"product": "Mouse", "qty": 80, "price": 20},
{"product": "Headset", "qty": 100, "price": 10}
]
row = 2
for item in sales_data:
sheet.Range[row, 1].Text = item["product"]
sheet.Range[row, 2].NumberValue = item["qty"]
sheet.Range[row, 3].NumberValue = item["price"]
sheet.Range[row, 4].NumberValue = item["qty"] * item["price"]
row += 1
workbook.SaveToFile("monthly_sales_report.xlsx")
workbook.Dispose()
L'aperçu du rapport de ventes mensuel :
Dans cet exemple, les valeurs de texte telles que les noms de produits sont écrites à l'aide de la propriété CellRange.Text, tandis que les champs numériques utilisent CellRange.NumberValue. Cela garantit que les quantités et les prix sont stockés sous forme de nombres dans Excel, permettant un calcul, un tri et une mise en forme appropriés.
Cette approche s'adapte naturellement à mesure que l'ensemble de données s'agrandit et maintient la logique métier séparée de la logique de sortie Excel. Pour plus d'exemples d'écriture Excel, veuillez vous référer à Comment automatiser l'écriture Excel en Python.
5. Mise en forme des données Excel pour des rapports réels en Python
Dans les rapports du monde réel, les fichiers Excel sont souvent livrés directement aux parties prenantes. Les données brutes sans mise en forme peuvent être difficiles à lire ou à interpréter.
Les tâches de mise en forme courantes incluent :
- Rendre les lignes d'en-tête visuellement distinctes
- Application de couleurs d'arrière-plan ou de bordures
- Mise en forme des nombres et des devises
- Ajustement automatique de la largeur des colonnes
L'exemple suivant montre comment ces opérations de mise en forme courantes peuvent être appliquées ensemble pour améliorer la lisibilité globale d'un rapport Excel généré.
Exemple Python : Amélioration de la lisibilité des rapports Excel
from spire.xls import Workbook, Color, LineStyleType
# Load the created Excel file
workbook = Workbook()
workbook.LoadFromFile("monthly_sales_report.xlsx")
# Get the first worksheet
sheet = workbook.Worksheets[0]
# Format header row
header_range = sheet.Range.Rows[0] # Get the first used row
header_range.Style.Font.IsBold = True
header_range.Style.Color = Color.get_LightBlue()
# Apply currency format
sheet.Range["C2:D6"].NumberFormat = "$#,##0.00"
# Format data rows
for i in range(1, sheet.Range.Rows.Count):
if i % 2 == 0:
row_range = sheet.Range[i, 1, i, sheet.Range.Columns.Count]
row_range.Style.Color = Color.get_LightGreen()
else:
row_range = sheet.Range[i, 1, i, sheet.Range.Columns.Count]
row_range.Style.Color = Color.get_LightYellow()
# Add borders to data rows
sheet.Range["A2:D6"].BorderAround(LineStyleType.Medium, Color.get_LightBlue())
# Auto-fit column widths
sheet.AllocatedRange.AutoFitColumns()
# Save the formatted Excel file
workbook.SaveToFile("monthly_sales_report_formatted.xlsx")
workbook.Dispose()
L'aperçu du rapport de ventes mensuel mis en forme :
Bien que la mise en forme ne soit pas strictement requise pour l'exactitude des données, elle est souvent attendue dans les rapports d'activité qui sont partagés ou archivés. Consultez Comment mettre en forme des feuilles de calcul Excel avec Python pour des techniques de mise en forme plus avancées.
6. Lecture et mise à jour de fichiers Excel existants dans l'automatisation Python
La mise à jour d'un fichier Excel existant implique généralement de localiser la bonne ligne avant d'écrire de nouvelles valeurs. Au lieu de mettre à jour une cellule fixe, les scripts d'automatisation analysent souvent les lignes pour trouver les enregistrements correspondants et appliquent les mises à jour de manière conditionnelle.
Exemple Python : Mise à jour d'un fichier Excel
from spire.xls import Workbook
workbook = Workbook()
workbook.LoadFromFile("monthly_sales_report.xlsx")
sheet = workbook.Worksheets[0]
# Locate the target row by product name
for row in range(2, sheet.LastRow + 1):
product_name = sheet.Range[row, 1].Text
if product_name == "Laptop":
sheet.Range[row, 5].Text = "Reviewed"
break
sheet.Range["E1"].Text = "Status"
workbook.SaveToFile("monthly_sales_report_updated.xlsx")
workbook.Dispose()
L'aperçu du rapport de ventes mensuel mis à jour :
7. Combinaison des opérations de lecture et d'écriture dans un seul flux de travail
Lorsque vous travaillez avec des fichiers Excel importés, les données brutes ne sont souvent pas immédiatement adaptées aux rapports ou à une analyse plus approfondie. Les problèmes courants incluent les enregistrements en double, les valeurs incohérentes ou les lignes incomplètes.
Cette section montre comment lire les données Excel existantes, les normaliser et écrire le résultat traité dans un nouveau fichier à l'aide de Python.
Dans les systèmes d'automatisation du monde réel, les fichiers Excel sont souvent utilisés comme porteurs de données intermédiaires plutôt que comme livrables finaux.
Ils peuvent être importés de plates-formes externes, modifiés manuellement par différentes équipes ou générés par des systèmes hérités avant d'être traités ultérieurement.
En conséquence, les données Excel brutes contiennent fréquemment des problèmes tels que :
- Plusieurs lignes pour la même entité commerciale
- Valeurs incohérentes ou non numériques
- Enregistrements vides ou incomplets
- Structures de données qui ne conviennent pas aux rapports ou à l'analyse
Une exigence courante est de lire les données Excel non affinées, d'appliquer des règles de normalisation en Python et d'écrire les résultats nettoyés dans une nouvelle feuille de calcul sur laquelle les utilisateurs en aval peuvent compter.
Exemple Python : Normalisation et agrégation des données de vente importées
Dans cet exemple, un fichier Excel de ventes brutes contient plusieurs lignes par produit.
L'objectif est de générer une feuille de calcul récapitulative propre où chaque produit n'apparaît qu'une seule fois, avec son montant total des ventes calculé par programme.
from spire.xls import Workbook, Color
workbook = Workbook()
workbook.LoadFromFile("raw_sales_data.xlsx")
source = workbook.Worksheets[0]
summary = workbook.Worksheets.Add("Summary")
# Define headers for the normalized output
summary.Range["A1"].Text = "Product"
summary.Range["B1"].Text = "Total Sales"
product_totals = {}
# Read raw data and aggregate values by product
for row in range(2, source.LastRow + 1):
product = source.Range[row, 1].Text
value = source.Range[row, 4].Value
# Skip incomplete or invalid rows
if not product or value is None:
continue
try:
amount = float(value)
except ValueError:
continue
if product not in product_totals:
product_totals[product] = 0
product_totals[product] += amount
# Write aggregated results to the summary worksheet
target_row = 2
for product, total in product_totals.items():
summary.Range[target_row, 1].Text = product
summary.Range[target_row, 2].NumberValue = total
target_row += 1
# Create a total row
summary.Range[summary.LastRow, 1].Text = "Total"
summary.Range[summary.LastRow, 2].Formula = "=SUM(B2:B" + str(summary.LastRow - 1) + ")"
# Format the summary worksheet
summary.Range.Style.Font.FontName = "Arial"
summary.Range[1, 1, 1, summary.LastColumn].Style.Font.Size = 12
summary.Range[1, 1, 1, summary.LastColumn].Style.Font.IsBold = True
for row in range(2, summary.LastRow + 1):
for column in range(1, summary.LastColumn + 1):
summary.Range[row, column].Style.Font.Size = 10
summary.Range[summary.LastRow, 1, summary.LastRow, summary.LastColumn].Style.Color = Color.get_LightGray()
summary.Range.AutoFitColumns()
workbook.SaveToFile("normalized_sales_summary.xlsx")
workbook.Dispose()
L'aperçu du résumé des ventes normalisé :
Python gère la validation des données, l'agrégation et la logique de normalisation, tandis qu'Excel reste le format de livraison final pour les utilisateurs professionnels, éliminant ainsi le besoin de nettoyage manuel ou de formules de tableur complexes.
Choisir la bonne approche Python pour la création de fichiers Excel
Python offre plusieurs façons de créer des fichiers Excel, et la meilleure approche dépend de la manière dont Excel est utilisé dans votre flux de travail.
Free Spire.XLS for Python est particulièrement bien adapté aux scénarios où :
- Les fichiers Excel sont générés ou mis à jour sans que Microsoft Excel soit installé
- Les fichiers sont produits par des services backend, des tâches par lots ou des tâches planifiées
- Vous avez besoin d'un contrôle précis sur la structure, la mise en forme et les formules de la feuille de calcul
- Excel est utilisé comme format de livraison ou d'échange, et non comme un outil d'analyse interactif
Pour l'exploration de données ou l'analyse statistique, les utilisateurs de Python peuvent s'appuyer sur d'autres bibliothèques en amont, tout en utilisant des bibliothèques de génération Excel comme Free Spire.XLS pour produire des fichiers structurés et prêts à être présentés à l'étape finale.
Cette séparation maintient la logique de traitement des données en Python et la logique de présentation dans Excel, améliorant la maintenabilité et la fiabilité.
Pour des conseils et des exemples plus détaillés, consultez le tutoriel Spire.XLS for Python.
8. Problèmes courants lors de la création et de l'écriture de fichiers Excel en Python
Lors de l'automatisation de la génération d'Excel, plusieurs problèmes pratiques sont fréquemment rencontrés.
-
Erreurs de chemin de fichier et d'autorisation
Vérifiez toujours que le répertoire cible existe et que le processus dispose d'un accès en écriture avant d'enregistrer les fichiers.
-
Types de données inattendus
Contrôlez explicitement si les valeurs sont écrites sous forme de texte ou de nombres pour éviter les erreurs de calcul dans Excel.
-
Écrasements de fichiers accidentels
Utilisez des noms de fichiers horodatés ou des répertoires de sortie pour éviter d'écraser les rapports existants.
-
Grands ensembles de données
Lorsque vous manipulez de grands volumes de données, écrivez les lignes séquentiellement et évitez les opérations de mise en forme inutiles à l'intérieur des boucles.
La résolution précoce de ces problèmes permet de garantir que l'automatisation d'Excel reste fiable à mesure que la taille et la complexité des données augmentent.
9. Conclusion
La création de fichiers Excel en Python est une solution pratique pour automatiser les rapports, l'exportation de données et les mises à jour de documents dans des environnements professionnels réels. En combinant la création de fichiers, l'écriture de données structurées, la mise en forme et les flux de travail de mise à jour, l'automatisation d'Excel peut aller au-delà des scripts ponctuels et faire partie d'un système stable.
Spire.XLS for Python fournit un moyen fiable de mettre en œuvre ces opérations dans des environnements où l'automatisation, la cohérence et la maintenabilité sont essentielles. Vous pouvez appliquer une licence temporaire pour libérer tout le potentiel de l'automatisation Python dans le traitement des fichiers Excel.
FAQ : Création de fichiers Excel en Python
Python peut-il créer des fichiers Excel sans que Microsoft Excel soit installé ?
Oui. Des bibliothèques telles que Spire.XLS for Python fonctionnent indépendamment de Microsoft Excel, ce qui les rend adaptées aux serveurs, aux environnements cloud et aux flux de travail automatisés.
Python est-il adapté à la génération de gros fichiers Excel ?
Python peut générer efficacement de gros fichiers Excel, à condition que les données soient écrites séquentiellement et que les opérations de mise en forme inutiles à l'intérieur des boucles soient évitées.
Comment puis-je empêcher l'écrasement des fichiers Excel existants ?
Une approche courante consiste à utiliser des noms de fichiers horodatés ou des répertoires de sortie dédiés lors de l'enregistrement des rapports Excel générés.
Python peut-il mettre à jour des fichiers Excel créés par d'autres systèmes ?
Oui. Python peut lire, modifier et étendre les fichiers Excel créés par d'autres applications, tant que le format de fichier est pris en charge.