Comment lire et traiter des feuilles Excel avec Pandas et OpenPyxl : du débutant au professionnel

Si vous êtes impliqué dans l'analyse de données ou si vous avez besoin d'automatiser des tâches répétitives dans des feuilles de calcul, combinez Python avec Excel est un coup gagnant pour accélérer votre flux de travailExcel reste l’outil le plus populaire dans de nombreuses entreprises, et découvrez comment empêcher Excel de convertir des nombres en datesPython vous offre puissance, flexibilité et un écosystème de bibliothèques conçues pour les données. Dans ce guide, vous découvrirez en détail comment lire et traiter des feuilles Excel avec pandas y ouvertpyxl, quand utiliser chacun d’eux et comment en tirer le meilleur parti dans des situations réelles.

Au-delà de l'ouverture d'un fichier et de l'examen de quelques cellules, vous apprendrez ici comment charger des feuilles et des plages spécifiques, filtrer, transformer et enregistrer les résultats, formatear Vous pourrez créer des cellules avec des styles avancés, créer des classeurs et des feuilles, générer des rapports automatisés et même des graphiques ou de petits tableaux de bord. Nous passerons des bases à des exemples pratiques, avec du code prêt à être adapté et des exemples concrets. recommandations de performance et meilleures pratiques pour éviter les goulots d’étranglement et les erreurs typiques.

Préparation de l'environnement et des bibliothèques nécessaires

Avant de commencer, assurez-vous d'avoir une version récente de Python installée ; il est recommandé Python 3.7 ou supérieur afin de garantir la compatibilité avec les bibliothèques que nous utiliserons. Pour vérifier votre version, vous pouvez exécuter la commande suivante dans le terminal.

python --version

Pour manipuler Excel en Python, les bibliothèques clés que vous allez utiliser sont pandas y ouvertpyxl; chacun couvre des besoins différents. Avec pépin Vous pouvez les installer en un instant et commencer à expérimenter.

pip install pandas openpyxl

Si vous préférez gérer les dépendances avec un gestionnaire comme Poetry, vous pouvez également installer les deux packages avec commandes simple, par exemple poésie ajouter des pandas y poésie ajouter openpyxl, ce qui vous aide maintenir un environnement reproductible par projet sans maux de tête.

Lire des livres, des feuilles et des cellules avec openpyxl

La bibliothèque ouvertpyxl Fonctionne directement sur les fichiers .xlsx, vous permettant d'ouvrir des classeurs, de manipuler des feuilles et de lire/écrire des cellules avec précision. C'est idéal lorsque vous en avez besoin. contrôle précis du format, appliquer des styles, des formules et travailler avec la structure Excel en tant que telle.

from openpyxl import load_workbook

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

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

Une fois le classeur ouvert, vous pouvez sélectionner une feuille par son nom et afficher des valeurs spécifiques. Cette approche est utile pour… inspecter les cellules ponctuelles ou parcourir les plages sans tout convertir en une structure tabulaire.

# Seleccionar una hoja concreta
sheet = workbook

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

Pour parcourir des lignes ou des plages, iter_rows est votre allié. Vous pouvez délimiter les lignes et les colonnes et traiter chaque cellule. Si vous ne lisez que, activer le mode lecture seule réduit la mémoire et améliore la vitesse sur les fichiers volumineux.

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

Lisez et écrivez des données efficacement avec pandas

Si votre objectif est analyse et manipulation de donnéesPandas est votre meilleure option. Il transforme les feuilles de calcul Excel en DataFrames (tableaux très puissants) pour filtrer, agréger, transformer et exporter les résultats plus rapidement qu'avec des boucles manuelles.

import pandas as pd

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

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

La fonction lire_excel Vous permet de charger des feuilles spécifiques, des colonnes spécifiques, ou d'ignorer les lignes initiales (très utile pour les fichiers avec des en-têtes ou des notes complexes). Cela vous donne contrôle et performance parce que vous évitez d'emporter des données dont vous n'avez pas besoin.

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

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

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

Une fois que vous avez terminé de transformer votre DataFrame, vous pouvez le transférer vers Excel avec une seule méthode. indice=Faux Évitez d’écrire l’index dans une colonne supplémentaire, ce qui est très courant lors de la préparation de rapports commerciaux.

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

Quand utiliser pandas et quand utiliser openpyxl

Bien qu’ils se complètent, ils ne répondent pas à la même problématique : Les pandas brillent dans le traitement de masse (filtrage, agrégations, jointures, nettoyage), tandis que openpyxl régit le format (styles, bordures, largeurs, formules, graphiques, création/suppression de feuilles, etc.). Bien choisir vous fera gagner du temps.

Si vous devez modifier des milliers de cellules avec une règle simple (par exemple, ajouter 10% à une colonne), avec pandas vous le ferez en une seule ligne ; dans openpyxl vous aurez besoin traverser les cellules avec des boucles et gérer les références. Cependant, si vous souhaitez appliquer une mise en forme et des styles d'entreprise, ou ajouter des graphiques à la feuille de calcul Excel finale, openpyxl est la solution idéale.

Une stratégie très utile consiste à combiner les deux : traiter avec pandas et, une fois la table finale générée, utiliser openpyxl pour polir la finition professionnelle (en-têtes gras et centrés, couleurs, formats numériques, etc.). Vous obtenez ainsi des performances et un résultat prêts à être présentés.

Opérations courantes avec pandas : sélection, filtrage et modifications

Avec Pandas, la sélection de colonnes et le filtrage conditionnel sont un jeu d'enfant. Cela vous permet de transformer de grands ensembles de données avec opérations vectorisées sans écrire de boucles, obtenant un code plus lisible et plus rapide.

import pandas as pd

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

# Selección de columnas
df_col = df]

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

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

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

Pour inspecter une seule pièce, vous pouvez utiliser .diriger() ou indexation .iloc Lorsque vous avez besoin de lignes/colonnes par position. De plus, lors de l'exportation, Pandas prend en charge formats multiples (CSV, Parquet, etc.), ce qui ouvre des possibilités au-delà d'Excel. Il est également courant de compléter Pandas par des guides sur opérations arithmétiques dans Excel lors de la migration de la logique entre les deux environnements.

Lecture et édition avec openpyxl : des cellules aux plages

Si l'objectif est le document Excel lui-même, openpyxl vous permet de créer des classeurs, d'ajouter des feuilles, de les renommer et de supprimer celles qui ne sont pas nécessaires. Ce contrôle détaillé est essentiel lorsque vous avez besoin de s'adapter à la mise en page d'un modèle ou maintenir les formules existantes.

from openpyxl import Workbook, load_workbook

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

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

L'accès aux cellules ou aux plages individuelles est simple. Vous pouvez également lire, modifier des valeurs et écrire De retour. Pour les modifications importantes, l'utilisation de plages et une structure Excel claire faciliteront votre travail.

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

# Modificar valores
ws = "Nuevo Nombre"

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

Appliquer des styles, des formats et des nombres avec OpenPyxl

L’un des avantages d’openpyxl est que vous pouvez habiller votre rapport avec polices, bordures, remplissages et alignements, ainsi que les formats numériques (comme deux décimales). Ceci est essentiel pour les rapports accessibles aux non-techniciens.

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

ws = wb

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

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

wb.save("datos_openpyxl.xlsx")

Vous pouvez également entrer formules excel directement dans les cellules, qui seront recalculées à l'ouverture du fichier dans Excel. Gardez à l'esprit que Les erreurs les plus courantes dans les formules Excel, qui apparaissent souvent lors du mélange de données générées par code et de logique de feuille de calcul.

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

Graphiques et visualisations simples dans Excel avec OpenPyxl

Pour compléter un rapport, il est parfois nécessaire d'inclure un graphique directement dans le classeur. Avec openpyxl, vous pouvez créer des graphiques à barres, en courbes ou autres à partir de plages de données et les placer dans un emplacement spécifique.

from openpyxl.chart import BarChart, Reference

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

Automatisation des rapports : combinaison de Pandas et d'OpenPyxl

Une recette très utile consiste à traiter les données avec des pandas (totaux, moyennes, regroupements) et à vider les résultats dans un nouveau classeur, que vous décorez ensuite avec openpyxl pour fournir un rapport bien formatéCe modèle s’adapte bien aux rapports périodiques.

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

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

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

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

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

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

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

wb.save("reporte_ventas.xlsx")

Si vous souhaitez également assurer une cohérence visuelle, ajoutez bordures fines et formats de nombres aux colonnes de montants. Ainsi, votre rapport est prêt à être partagé sans aucune modification manuelle dans Excel ; et si vous devez automatiser le remplissage, vous pouvez compter sur des techniques pour remplir automatiquement les données en fonction de modèles.

Processus typiques : filtrage, transformation et sauvegarde avec Pandas

Un cas courant consiste à filtrer selon une condition et à enregistrer le résultat dans un nouveau fichier. Cela se fait en quelques lignes avec pandas et donne le résultat suivant : idéal pour le nettoyage des canalisations ou la préparation des données pour les équipes commerciales.

import pandas as pd

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

# Filtrar ventas > 1000
filtrado = df > 1000]

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

Si vous devez conserver une colonne d'origine et en créer une modifiée (par exemple, ajouter 10 % à la « Surface totale »), l'opération vectorisée évite les boucles et vous laisse avec un DataFrame propre et facile à inspecter.

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

df = df
df = df * 1.1

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

Si vous préférez également masquer temporairement les résultats dans le fichier final au lieu de les supprimer, pensez aux règles pour masquer les lignes en fonction de la valeur de la cellule et faciliter l’évaluation en équipe.

Suppression de lignes et nettoyage des données

Une autre tâche courante consiste à supprimer des enregistrements par position ou par condition. Avec Pandas, supprimer les 10 premières lignes est simple grâce à l'index ; pour des filtres plus complexes, utiliser des expressions booléennes sans boucles for.

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

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

Si votre nettoyage dépend de règles telles que « supprimer les lignes avec une surface totale uniforme », vous pouvez créer une condition et l'appliquer, en conservant le code expressif et maintenable contre les boucles et les compteurs manuels. Et si la feuille est protégée, rappelez-vous comment déprotéger une feuille Excel avec un mot de passe avant de le modifier.

Édition et suppression avec openpyxl : cellules et lignes

Avec OpenPyxl, modifier une colonne entière implique de parcourir les cellules. L'avantage est de pouvoir insérer de nouvelles colonnes. respecter la disposition d'origine et enregistrez-le dans un autre fichier sans casser le format.

from openpyxl import load_workbook
from openpyxl.utils import get_column_letter

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

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

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

wb.save("cultivos_modify.xlsx")

Pour supprimer des lignes par position, openpyxl le résout également avec un appel, bien que pour conditions avancées Vous devrez itérer et décider ce qu'il faut supprimer en fonction du contenu de chaque ligne.

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

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

Consolider plusieurs fichiers Excel en un seul

Un classique : vous avez des dizaines de fichiers .xlsx avec le même schéma et vous souhaitez les joindre dans une seule table pour les analyser. Avec Pandas et Glob, cela peut se faire en quelques lignes, sans ouvrir manuellement chaque fichier.

import pandas as pd
import glob

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

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

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

Cette approche est parfaite pour les intégrations mensuelles, les rapports multi-délégations ou tout processus où vous recevez plusieurs livres avec une structure homogène.

Générer automatiquement des rapports par service

À partir d'un fichier avec des ventes globales, vous pouvez segmenter par département et générer un rapport personnalisé pour chacun automatiquement. Chaque fichier est prêt à être partagé avec votre équipe.

import pandas as pd

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

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

Si vous devez également formater chaque rapport, vous pouvez charger le fichier résultant avec openpyxl et en-têtes de style, ajustez la largeur des colonnes et ajoutez une couleur d'entreprise. Vous pouvez également automatiser l'organisation des fichiers et créer des dossiers et sous-dossiers en cascade pour chaque département.

Petit tableau de bord interactif avec Tkinter et pandas

Pour un prototypage rapide, vous pouvez créer une fenêtre simple qui affiche les colonnes et calcule la moyenne de celle sélectionnée. Ce n'est pas une solution complète de BI, mais elle fonctionne pour validations express sans quitter Python.

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

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

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

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

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

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

root.mainloop()

Pour des projets de reporting plus complexes, vous souhaiterez peut-être déplacer cela vers une application Web avec Streamlit ou Dash, mais pour un utilitaire local rapide, Tkinter peut vous sortir d'une situation difficile avec très peu de code.

Analyse exploratoire : statistiques et graphiques avec Pandas et Matplotlib

Lorsque votre fichier Excel contient des informations sur les clients ou les ventes, il est judicieux d'examiner rapidement les distributions et les relations. Avec Pandas, vous pouvez obtenir des statistiques descriptives et, avec Matplotlib, générer des statistiques. histogrammes et nuages ​​de points très utile.

import pandas as pd
import matplotlib.pyplot as plt

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

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

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

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

Cela vous permet de détecter les valeurs aberrantes, les biais ou les relations intéressantes pour les analyser plus en détail ultérieurement. Pour générer des rapports dans Excel, exportez des tableaux récapitulatifs avec Pandas et créer des graphiques dans le livre avec openpyxl pour un livrable complet. Pour des analyses statistiques spécifiques, vous pouvez également consulter le fonction quartile dans Excel comme référence lors de la migration des indicateurs.

Sauvegarde des résultats avec pandas et openpyxl

Avec Pandas, l'écriture vers Excel est instantanée ; de plus, vous pouvez exporter vers d'autres formats comme CSV ou Parquet. Si le fichier est destiné à une utilisation professionnelle, ajoutez feuilles avec des détails différents ou des données filtrées par segments dans le même livre.

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

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

Si vous travaillez avec openpyxl, n'oubliez pas que vous pouvez créer de nouvelles colonnes et les remplir par plage. C'est une méthode simple. marquer les enregistrements examinés dans des rapports à structure fixe.

from openpyxl import load_workbook

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

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

wb.save("cultivos_modify_openpyxl.xlsx")

Performances et bonnes pratiques

Pour les fichiers volumineux, il est judicieux de limiter la quantité de données récupérées en mémoire. Dans Pandas, lire uniquement les colonnes nécessaires avec usecols et évitez de traiter des feuilles non pertinentes. Dans openpyxl, utilisez lecture seule = Vrai lire et write_only=Vrai pour écrire.

Attention aux types de données : Excel enregistre parfois les nombres au format texte, ce qui peut perturber les filtres et les agrégations. Lors du chargement avec Pandas, vous pouvez spécifier des types de données ou normaliser les colonnes après lecture pour éviter les surprises avec les dates, les montants ou les identifiants.

Avec les formules Excel, n'oubliez pas que toutes les fonctions ne sont pas prises en charge de la même manière par les bibliothèques ; très probablement sont recalculés lors de leur ouverture dans ExcelSi vous avez besoin de valeurs fixes, évaluez d'abord avec pandas et réécrivez les nombres pré-calculés.

Concernant la compatibilité, priorisez les fichiers . Xlsx (format moderne) et testez vos scripts avec différentes versions d'Excel lorsque vos utilisateurs ont des environnements hétérogènes. Cela réduit les problèmes liés aux fonctions ou fonctionnalités non prises en charge dans les anciennes versions.

En guise de note finale, pensez aux pipelines reproductibles : définissez les dépendances (Poetry, requirements.txt), documentez vos paramètres (sheet_name, usecols, skiprows) et ajoutez journaux minimum pour le débogage. Cela vous fera gagner du temps lors de la mise à l'échelle de votre projet ou de la modification de votre source de données.

Si vous êtes arrivé jusqu'ici, vous maîtrisez déjà la lecture, le traitement et l'écriture d'Excel avec pandas et openpyxl, vous savez quand chaque outil est approprié et comment les combiner pour des rapports professionnels. Désormais, vous visualiserez vos feuilles de calcul comme sources et destinations au sein d'un flux de travail robuste, automatisé et beaucoup plus rapide.