Pandas Read Excel : Comment importer des fichiers Excel en Python

Name

Soren Atelier

Updated on 09/02/2026

Les fichiers Excel restent le format le plus courant pour stocker des données tabulaires dans les environnements professionnels, pourtant leur importation dans Python pour l'analyse crée souvent des frictions. Vous devez gérer plusieurs feuilles, des types de données incohérents, des valeurs manquantes et des contraintes de mémoire, tout en maintenant l'intégrité des données. La fonction read_excel() de pandas résout ces défis, mais seulement si vous savez comment configurer correctement ses plus de 30 paramètres.

Ce guide vous montre comment importer efficacement des fichiers Excel dans des pandas DataFrames, des importations basiques d'une seule feuille aux scénarios avancés comme la lecture simultanée de plusieurs feuilles, la gestion de gros fichiers et le dépannage d'erreurs courantes.

Utilisation de base de pandas read_excel()

La façon la plus simple de lire un fichier Excel dans un pandas DataFrame nécessite uniquement le chemin du fichier :

import pandas as pd
 
# Lire la première feuille d'un fichier Excel
df = pd.read_excel('data.xlsx')
print(df.head())

Cela lit la première feuille par défaut, en traitant la première ligne comme des en-têtes de colonnes. La fonction détecte automatiquement le format du fichier (.xlsx ou .xls) et utilise le moteur approprié.

Pour les fichiers dans différents répertoires, utilisez des chemins absolus ou relatifs :

# Chemin absolu
df = pd.read_excel('/Users/username/Documents/sales_data.xlsx')
 
# Chemin relatif
df = pd.read_excel('../data/sales_data.xlsx')

Comprendre les paramètres clés

La fonction read_excel() offre un contrôle étendu sur la manière dont les données sont importées. Voici un tableau de référence des paramètres les plus importants :

Travailler avec plusieurs feuilles

Lire une feuille spécifique

Spécifiez les feuilles par nom ou index (base 0) :

# Lire par nom de feuille
df = pd.read_excel('financial_report.xlsx', sheet_name='Q1 Revenue')
 
# Lire par index (0 = première feuille)
df = pd.read_excel('financial_report.xlsx', sheet_name=0)

Lire plusieurs feuilles à la fois

Passez une liste de noms de feuilles ou d'indices pour importer plusieurs feuilles dans un dictionnaire de DataFrames :

# Lire plusieurs feuilles spécifiques
sheets_dict = pd.read_excel('annual_report.xlsx',
                            sheet_name=['Q1', 'Q2', 'Q3', 'Q4'])
 
# Accéder aux DataFrames individuels
q1_df = sheets_dict['Q1']
q2_df = sheets_dict['Q2']
 
print(f"Q1 shape: {q1_df.shape}")
print(f"Q2 shape: {q2_df.shape}")

Lire toutes les feuilles

Utilisez sheet_name=None pour importer chaque feuille du classeur :

# Lire toutes les feuilles dans un dictionnaire
all_sheets = pd.read_excel('company_data.xlsx', sheet_name=None)
 
# Itérer à travers toutes les feuilles
for sheet_name, df in all_sheets.items():
    print(f"\nSheet: {sheet_name}")
    print(f"Shape: {df.shape}")
    print(f"Columns: {df.columns.tolist()}")

Ceci est particulièrement utile lorsque vous devez traiter plusieurs feuilles avec des structures similaires :

# Combiner toutes les feuilles en un seul DataFrame
all_sheets = pd.read_excel('monthly_sales.xlsx', sheet_name=None)
combined_df = pd.concat(all_sheets.values(), ignore_index=True)
print(f"Combined shape: {combined_df.shape}")

Contrôler l'importation de données avec les en-têtes et les colonnes

Spécifier les lignes d'en-tête

Contrôlez quelle ligne devient les noms de colonnes :

# Sauter les 2 premières lignes, utiliser la ligne 3 comme en-tête
df = pd.read_excel('data.xlsx', header=2)
 
# Pas de ligne d'en-tête - pandas attribue des noms de colonnes numériques
df = pd.read_excel('data.xlsx', header=None)
 
# En-têtes de colonnes multi-niveaux
df = pd.read_excel('data.xlsx', header=[0, 1])

Sauter des lignes

Supprimez les lignes non désirées du haut du fichier :

# Sauter les 3 premières lignes
df = pd.read_excel('data.xlsx', skiprows=3)
 
# Sauter des lignes spécifiques (indexées à partir de 0)
df = pd.read_excel('data.xlsx', skiprows=[0, 2, 5])
 
# Sauter des lignes en utilisant une fonction
df = pd.read_excel('data.xlsx', skiprows=lambda x: x % 2 == 0)  # Sauter les lignes paires

Sélectionner des colonnes spécifiques

Importez uniquement les colonnes dont vous avez besoin pour réduire l'utilisation de la mémoire :

# Sélectionner les colonnes par plage de lettres
df = pd.read_excel('data.xlsx', usecols='A:D')
 
# Sélectionner des colonnes spécifiques par lettre
df = pd.read_excel('data.xlsx', usecols='A,C,E,G')
 
# Sélectionner les colonnes par index
df = pd.read_excel('data.xlsx', usecols=[0, 2, 4, 6])
 
# Sélectionner les colonnes par nom
df = pd.read_excel('data.xlsx', usecols=['Name', 'Age', 'Salary'])
 
# Sélectionner les colonnes en utilisant une fonction
df = pd.read_excel('data.xlsx', usecols=lambda x: 'total' in x.lower())

Spécification et conversion des types de données

Définir les types de données des colonnes

Définissez explicitement les types de données pour éviter les erreurs d'inférence automatique :

# Spécifier les dtypes pour plusieurs colonnes
df = pd.read_excel('customer_data.xlsx',
                   dtype={
                       'CustomerID': str,
                       'ZipCode': str,
                       'Age': int,
                       'Revenue': float
                   })
 
# Conserver les ID numériques comme chaînes pour préserver les zéros initiaux
df = pd.read_excel('products.xlsx', dtype={'ProductID': str})

Gestion des dates

Analysez les colonnes de dates automatiquement :

# Analyser une seule colonne de date
df = pd.read_excel('orders.xlsx', parse_dates=['OrderDate'])
 
# Analyser plusieurs colonnes de dates
df = pd.read_excel('employee_data.xlsx',
                   parse_dates=['HireDate', 'TerminationDate'])
 
# Combiner des colonnes en un seul datetime
df = pd.read_excel('logs.xlsx',
                   parse_dates={'DateTime': ['Date', 'Time']})
 
# Vérifier le résultat
print(df.dtypes)

Gérer les valeurs manquantes

Contrôlez comment pandas identifie et gère les données manquantes :

# Reconnaître les indicateurs personnalisés de valeurs manquantes
df = pd.read_excel('survey_data.xlsx',
                   na_values=['NA', 'N/A', 'null', 'None', '-'])
 
# Valeurs NA différentes par colonne
df = pd.read_excel('mixed_data.xlsx',
                   na_values={
                       'Age': ['Unknown', 'N/A'],
                       'Salary': [0, -1, 'Not Disclosed']
                   })
 
# Conserver les valeurs NA par défaut et en ajouter d'autres
df = pd.read_excel('data.xlsx',
                   na_values=['Missing'],
                   keep_default_na=True)

Gestion de gros fichiers Excel

Les fichiers Excel consomment une mémoire importante lorsqu'ils sont chargés entièrement en RAM. Utilisez ces stratégies pour les grands ensembles de données :

Limiter les lignes

Lisez uniquement les lignes dont vous avez besoin :

# Lire les 10 000 premières lignes
df = pd.read_excel('large_file.xlsx', nrows=10000)
 
# Lire une plage spécifique de lignes en utilisant skiprows et nrows
df = pd.read_excel('large_file.xlsx', skiprows=1000, nrows=5000)

Utiliser des convertisseurs pour l'efficacité mémoire

Appliquez des transformations pendant l'importation pour réduire l'empreinte mémoire :

# Convertir les colonnes pendant la lecture
def categorize_status(value):
    return 'Active' if value == 1 else 'Inactive'
 
df = pd.read_excel('users.xlsx',
                   converters={
                       'Status': categorize_status,
                       'Category': lambda x: x.lower().strip()
                   })

Traiter les feuilles de manière itérative

Pour les classeurs avec plusieurs grandes feuilles, traitez une feuille à la fois :

import pandas as pd
 
# Obtenir d'abord tous les noms de feuilles
xls = pd.ExcelFile('massive_workbook.xlsx')
sheet_names = xls.sheet_names
 
# Traiter chaque feuille séparément
for sheet in sheet_names:
    df = pd.read_excel(xls, sheet_name=sheet, nrows=10000)
    # Traiter df ici
    result = df.describe()
    print(f"\n{sheet} Summary:\n{result}")

Alternative : Utiliser openpyxl pour le streaming

Pour les fichiers extrêmement volumineux, envisagez de lire ligne par ligne avec openpyxl :

from openpyxl import load_workbook
 
# Charger le classeur en mode lecture seule
wb = load_workbook('huge_file.xlsx', read_only=True)
ws = wb['Sheet1']
 
# Traiter les lignes de manière itérative
data = []
for row in ws.iter_rows(min_row=2, max_row=1000, values_only=True):
    data.append(row)
 
# Convertir en DataFrame
df = pd.DataFrame(data, columns=['Col1', 'Col2', 'Col3'])
wb.close()

Comprendre les moteurs Excel

Pandas utilise différentes bibliothèques pour lire les fichiers Excel selon le format et les paquets installés :

Spécifiez le moteur explicitement :

# Forcer le moteur openpyxl
df = pd.read_excel('data.xlsx', engine='openpyxl')
 
# Lire un fichier .xls hérité
df = pd.read_excel('old_data.xls', engine='xlrd')
 
# Lire un fichier Excel binaire
df = pd.read_excel('data.xlsb', engine='pyxlsb')

Pandas read_excel vs read_csv : Différences clés

Bien que les deux fonctions créent des DataFrames, elles ont des différences importantes :

Recommandation : Utilisez read_csv() pour le traitement de données à grande échelle et read_excel() lorsque vous devez travailler avec des classeurs Excel existants ou plusieurs feuilles.

Visualisez les données Excel instantanément avec PyGWalker

Après avoir importé des données Excel avec pandas, vous devez souvent les explorer visuellement. PyGWalker (opens in a new tab) transforme votre DataFrame en une interface de visualisation interactive semblable à Tableau directement dans votre notebook Jupyter, sans avoir besoin d'écrire du code de traçage.

import pandas as pd
import pygwalker as pyg
 
# Lire les données Excel
df = pd.read_excel('sales_data.xlsx')
 
# Lancer la visualisation interactive
pyg.walk(df)

Cela ouvre une interface glisser-déposer où vous pouvez :

• Créer des graphiques en faisant glisser les colonnes vers des canaux visuels
• Basculer instantanément entre les types de graphiques (barres, ligne, nuage de points, carte thermique)
• Appliquer des filtres et des agrégations de manière interactive
• Exporter les visualisations sous forme d'images ou de code

PyGWalker est particulièrement utile pour l'analyse exploratoire des données après l'importation de fichiers Excel, vous permettant de comprendre les distributions et les relations de données sans écrire de code matplotlib ou seaborn.

Erreurs courantes et dépannage

ModuleNotFoundError: No module named 'openpyxl'

C'est l'erreur la plus courante lors de la lecture de fichiers .xlsx :

ImportError: Missing optional dependency 'openpyxl'. Use pip or conda to install openpyxl.

Solution : Installez le moteur requis :

# Installer openpyxl
pip install openpyxl
 
# Ou installer toutes les dépendances Excel
pip install pandas[excel]

XLRDError: Excel xlsx file; not supported

Si vous voyez cette erreur, xlrd tente de lire un fichier .xlsx (ne supporte que .xls depuis la version 2.0) :

Solution : Installez openpyxl ou spécifiez le moteur :

df = pd.read_excel('data.xlsx', engine='openpyxl')

FileNotFoundError

Vérifiez votre chemin de fichier et répertoire de travail :

import os
 
# Afficher le répertoire actuel
print(os.getcwd())
 
# Lister les fichiers dans le répertoire
print(os.listdir('.'))
 
# Utiliser un chemin absolu
df = pd.read_excel('/absolute/path/to/file.xlsx')

Erreurs de mémoire avec de gros fichiers

Si pandas plante avec des erreurs de mémoire :

# Réduire la mémoire en sélectionnant les colonnes
df = pd.read_excel('large_file.xlsx', usecols=['A', 'B', 'C'])
 
# Limiter les lignes
df = pd.read_excel('large_file.xlsx', nrows=50000)
 
# Spécifier les dtypes pour réduire la mémoire
df = pd.read_excel('large_file.xlsx',
                   dtype={'ID': 'int32', 'Category': 'category'})

ValueError: Excel file format cannot be determined

Cela se produit lorsque l'extension du fichier ne correspond pas au format réel :

Solution : Spécifiez le moteur explicitement ou renommez le fichier avec l'extension correcte :

# Essayer différents moteurs
df = pd.read_excel('data.xlsx', engine='openpyxl')

Problèmes d'analyse des dates

Excel stocke les dates sous forme de numéros de série. Si les dates ne sont pas analysées correctement :

# Forcer l'analyse des dates
df = pd.read_excel('data.xlsx', parse_dates=['DateColumn'])
 
# Conversion manuelle
df['DateColumn'] = pd.to_datetime(df['DateColumn'])

Techniques avancées

Lire des fichiers protégés par mot de passe

Bien que pandas ne prenne pas en charge directement les fichiers protégés par mot de passe, utilisez msoffcrypto-tool :

import msoffcrypto
import io
import pandas as pd
 
# Déchiffrer le fichier
decrypted = io.BytesIO()
with open('protected.xlsx', 'rb') as f:
    file = msoffcrypto.OfficeFile(f)
    file.load_key(password='yourpassword')
    file.decrypt(decrypted)
 
# Lire le fichier déchiffré
df = pd.read_excel(decrypted)

Combiner read_excel avec des gestionnaires de contexte

Pour une meilleure gestion des ressources :

from contextlib import closing
import pandas as pd
 
with closing(pd.ExcelFile('data.xlsx')) as xls:
    df1 = pd.read_excel(xls, sheet_name='Sheet1')
    df2 = pd.read_excel(xls, sheet_name='Sheet2')
    # Le fichier est automatiquement fermé après ce bloc

Travailler avec des URLs

Lisez les fichiers Excel directement depuis des URLs :

url = 'https://example.com/data.xlsx'
df = pd.read_excel(url)

Utiliser RunCell pour le débogage de données Excel

Lorsque vous travaillez avec des importations Excel complexes dans des notebooks Jupyter, RunCell (opens in a new tab) fournit une assistance alimentée par l'IA pour déboguer les erreurs d'importation, optimiser les paramètres et corriger les problèmes de types de données. L'agent IA peut :

• Diagnostiquer pourquoi read_excel() n'analyse pas correctement les dates
• Suggérer des spécifications dtype optimales pour l'efficacité mémoire
• Déboguer les problèmes de compatibilité des moteurs
• Aider à dépanner les problèmes d'encodage et de formatage

Ceci est particulièrement précieux lors de l'importation de fichiers Excel du monde réel désordonnés avec un formatage incohérent ou des structures multi-feuilles complexes.

FAQ

Comment lire un fichier Excel sans en-têtes dans pandas ?

Définissez header=None pour indiquer à pandas que la première ligne est des données, pas des noms de colonnes. Pandas attribuera des noms de colonnes numériques (0, 1, 2...) :

df = pd.read_excel('data.xlsx', header=None)

Vous pouvez ensuite renommer les colonnes manuellement :

df.columns = ['Name', 'Age', 'Salary']

Pandas peut-il lire plusieurs fichiers Excel à la fois ?

Oui, utilisez une boucle ou une compréhension de liste pour lire plusieurs fichiers et les concaténer :

import pandas as pd
from glob import glob
 
# Lire tous les fichiers Excel dans un répertoire
files = glob('data/*.xlsx')
dfs = [pd.read_excel(f) for f in files]
combined_df = pd.concat(dfs, ignore_index=True)

Comment lire uniquement des lignes spécifiques d'un fichier Excel ?

Combinez les paramètres skiprows et nrows :

# Lire les lignes 100-199 (sauter les 100 premières, lire les 100 suivantes)
df = pd.read_excel('data.xlsx', skiprows=100, nrows=100)

Pourquoi read_excel est-il si lent comparé à read_csv ?

Les fichiers Excel sont des formats binaires qui nécessitent une analyse complexe, tandis que les fichiers CSV sont du texte brut. Pour les grands ensembles de données, convertissez d'abord Excel en CSV :

# Conversion unique
df = pd.read_excel('large_file.xlsx')
df.to_csv('large_file.csv', index=False)
 
# Les lectures futures utilisent CSV
df = pd.read_csv('large_file.csv')  # Beaucoup plus rapide

Comment gérer les cellules fusionnées dans les fichiers Excel ?

Pandas lit la valeur en haut à gauche des cellules fusionnées et remplit le reste avec NaN. Vous pouvez propager ces valeurs vers l'avant :

df = pd.read_excel('data.xlsx')
df['MergedColumn'] = df['MergedColumn'].fillna(method='ffill')

Conclusion

La fonction pandas read_excel() fournit un contrôle complet sur l'importation de fichiers Excel en Python, des importations simples d'une seule feuille aux scénarios complexes impliquant plusieurs feuilles, des types de données personnalisés et la gestion de gros fichiers. Maîtrisez les paramètres clés – sheet_name, usecols, dtype, parse_dates et skiprows – pour importer les données de manière efficace et précise.

Pour la plupart des flux de travail, le pd.read_excel('file.xlsx') de base suffit, mais comprendre les options avancées comme la sélection du moteur, les fonctions de conversion et les techniques d'optimisation de la mémoire devient critique lorsque vous travaillez avec des données professionnelles du monde réel. N'oubliez pas d'installer le moteur approprié (openpyxl pour les fichiers .xlsx) et envisagez de convertir les gros fichiers Excel en CSV pour de meilleures performances.

La combinaison de pandas pour l'importation de données, PyGWalker pour la visualisation instantanée et RunCell pour le débogage crée un flux de travail puissant pour l'analyse de données Excel en Python.