Lire des fichiers Excel en R : readxl et openxlsx

Importer un fichier xls ou xlsx dans un data frame — choisir une feuille, une plage ou les types de colonnes

Lisez des fichiers Excel (xls et xlsx) dans R avec readxl::read_excel() et openxlsx::read.xlsx(). Listez les feuilles avec excel_sheets(), lisez une feuille précise ou une plage de cellules, définissez les types de colonnes, ignorez des lignes d’en-tête et gérez les valeurs manquantes — les deux packages présentés côte à côte.

AstucePoints clés

• readxl : read_excel("file.xlsx") lit à la fois les fichiers .xls et .xlsx — sans Java, sans dépendances externes.
• Listez d’abord les onglets avec excel_sheets("file.xlsx"), puis lisez-en un avec sheet = (nom ou numéro).
• Lisez une partie d’une feuille avec range = "B2:D10" ; contrôlez l’analyse avec col_types =, skip =, na =.
• openxlsx : read.xlsx("file.xlsx", sheet = 1) est l’alternative légère en dépendances (xlsx uniquement).
• Laissez de côté les anciens packages xlsx/XLConnect basés sur Java — readxl et openxlsx sont plus rapides et s’installent proprement.

Introduction

Vous avez un tableur — des résultats d’enquête, un export de laboratoire, le .xlsx d’un collègue — et vous devez l’amener dans R sous forme de data frame. L’outil fiable est readxl : il lit à la fois les fichiers .xls et .xlsx, devine sensément les types de colonnes et n’a aucune dépendance externe (ni Java, ni Perl), si bien qu’il s’installe de la même façon sur chaque machine.

Cette leçon lit un vrai fichier Excel de bout en bout : lister ses feuilles, en lire une, récupérer une plage précise, corriger les types de colonnes et traiter des marqueurs de valeurs manquantes inhabituels. Pour que chaque bloc s’exécute ici et dans votre navigateur, on commence par écrire un petit fichier d’exemple à partir d’un jeu de données intégré, puis on le relit — le code de lecture est exactement celui que vous exécuteriez sur votre propre fichier.

Deux packages couvrent presque tous les cas :

• readxl read_excel() — la valeur par défaut moderne pour lire. Renvoie un tibble ; gère .xls et .xlsx.
• openxlsx read.xlsx() — une alternative légère en dépendances qui sait aussi écrire et styliser (.xlsx uniquement).

Préparer un fichier d’exemple à lire

Les lectures ci-dessous ont besoin d’un fichier. On écrit iris dans un .xlsx temporaire avec writexl::write_xlsx(), pour que la page soit autonome — quand vous lirez votre fichier, remplacez xlsx_path par son chemin (par ex. "data/survey.xlsx").

library(writexl)
xlsx_path <- tempfile(fileext = ".xlsx")   # your own path goes here: "data/survey.xlsx"
write_xlsx(head(iris, 10), xlsx_path)
file.exists(xlsx_path)

[1] TRUE

Lire un fichier Excel avec readxl

read_excel() prend le chemin du fichier et renvoie un tibble. Il détecte .xls ou .xlsx d’après l’extension, donc le même appel fonctionne pour les deux.

library(readxl)
my_data <- read_excel(xlsx_path)
my_data

# A tibble: 10 × 5
   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
          <dbl>       <dbl>        <dbl>       <dbl> <chr>  
 1          5.1         3.5          1.4         0.2 setosa 
 2          4.9         3            1.4         0.2 setosa 
 3          4.7         3.2          1.3         0.2 setosa 
 4          4.6         3.1          1.5         0.2 setosa 
 5          5           3.6          1.4         0.2 setosa 
 6          5.4         3.9          1.7         0.4 setosa 
 7          4.6         3.4          1.4         0.3 setosa 
 8          5           3.4          1.5         0.2 setosa 
 9          4.4         2.9          1.4         0.2 setosa 
10          4.9         3.1          1.5         0.1 setosa 

Voilà toute la recette pour un fichier à une seule feuille : un appel, aucun argument. Les types de colonnes sont déduits des données — les nombres arrivent en <dbl>, le texte en <chr>.

Note

De façon interactive, read_excel(file.choose()) ouvre un sélecteur de fichiers pour vous éviter de taper le chemin — pratique quand vous débutez.

Lister les feuilles, puis en lire une

Un classeur a souvent plusieurs onglets. Listez-les d’abord pour lire le bon — ne devinez jamais l’index.

library(readxl)
excel_sheets(xlsx_path)

[1] "measurements" "summary"     

Lisez maintenant une feuille précise par nom (robuste) ou par index (fragile si les onglets sont réorganisés) :

library(readxl)
# by name — preferred
read_excel(xlsx_path, sheet = "summary")

# A tibble: 4 × 3
    mpg   cyl  disp
  <dbl> <dbl> <dbl>
1  21       6   160
2  21       6   160
3  22.8     4   108
4  21.4     6   258

library(readxl)
# by position — the 2nd tab
read_excel(xlsx_path, sheet = 2)

# A tibble: 4 × 3
    mpg   cyl  disp
  <dbl> <dbl> <dbl>
1  21       6   160
2  21       6   160
3  22.8     4   108
4  21.4     6   258

Lire seulement une partie d’une feuille

Quand une feuille comporte des notes au-dessus du tableau, un logo ou des colonnes en trop, lisez uniquement le bloc voulu avec range = (style Excel "A1:C20") — ou ignorez les premières lignes avec skip =.

library(readxl)
# top-left 3x3 block of the first sheet
read_excel(xlsx_path, sheet = "measurements", range = "A1:C3")

# A tibble: 2 × 3
  Sepal.Length Sepal.Width Petal.Length
         <dbl>       <dbl>        <dbl>
1          5.1         3.5          1.4
2          4.9         3            1.4

library(readxl)
# drop the first row, then take column names from the next one
read_excel(xlsx_path, sheet = "summary", skip = 1)

# A tibble: 3 × 3
   `21`   `6` `160`
  <dbl> <dbl> <dbl>
1  21       6   160
2  22.8     4   108
3  21.4     6   258

skip = 1 supprime la ligne du haut avant la lecture ; la ligne suivante devient l’en-tête. Combinez avec col_names = FALSE si votre feuille n’a aucun en-tête.

Contrôler la façon dont les colonnes sont analysées

Parfois la supposition de readxl est fausse — une colonne d’ID lue comme un nombre perd ses zéros de tête, ou une date arrive sous forme de texte. Définissez col_types = pour forcer l’analyse. Un type par colonne ; "guess" conserve la valeur par défaut pour cette colonne.

library(readxl)
read_excel(
  xlsx_path,
  sheet = "measurements",
  col_types = c("numeric", "numeric", "numeric", "numeric", "text")
)

# A tibble: 5 × 5
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
         <dbl>       <dbl>        <dbl>       <dbl> <chr>  
1          5.1         3.5          1.4         0.2 setosa 
2          4.9         3            1.4         0.2 setosa 
3          4.7         3.2          1.3         0.2 setosa 
4          4.6         3.1          1.5         0.2 setosa 
5          5           3.6          1.4         0.2 setosa 

Les types valides sont "skip", "guess", "logical", "numeric", "date", "text" et "list". Utilisez "skip" pour ignorer entièrement une colonne lors de la lecture.

Gérer les valeurs manquantes et les noms en double

Si les cellules vides ne sont pas le seul marqueur « manquant » — disons que le fichier utilise "---" ou "N/A" — passez-les à na = pour qu’ils soient importés en NA plutôt qu’en texte. Et si deux colonnes partagent un nom, .name_repair = "unique" les rend utilisables sans risque.

library(readxl)
read_excel(
  xlsx_path,
  sheet = "summary",
  na = c("", "NA", "---"),       # treat these as missing
  .name_repair = "unique"        # disambiguate duplicate column names
)

# A tibble: 4 × 3
    mpg   cyl  disp
  <dbl> <dbl> <dbl>
1  21       6   160
2  21       6   160
3  22.8     4   108
4  21.4     6   258

Lire avec openxlsx à la place

openxlsx lit aussi les .xlsx, renvoie un data.frame simple et — contrairement à readxl — écrit et stylise également les classeurs, donc vous l’avez peut-être déjà chargé. Il n’a pas non plus de dépendance Java.

library(openxlsx)
# sheet by index or name; getSheetNames() lists the tabs
getSheetNames(xlsx_path)

[1] "measurements" "summary"     

read.xlsx(xlsx_path, sheet = "measurements")

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa

read.xlsx() accepte startRow =, rows =, cols = et detectDates = TRUE pour un contrôle plus fin. Notez qu’il ne lit que les .xlsx (pas l’ancien .xls) — pour les vieux fichiers .xls, utilisez readxl.

Essayez en direct

Les blocs ci-dessus se sont exécutés au moment de la compilation. Modifiez celui-ci et appuyez sur Run — il écrit un petit fichier Excel, puis le relit de deux façons, entièrement dans votre navigateur via webR (sans installation).

🟢 Avec un agent IA

Collez les premières lignes de votre tableur et demandez à Prova « quels arguments de read_excel() me faut-il — sheet, range ou col_types ? » Elle écrit l’appel, et comme le runtime est juste là, vous l’exécutez pour confirmer que les données arrivent bien correctement depuis votre fichier. Demander à Prova →

Vous travaillez en Python ? Un guide pandas read_excel arrive dans la série Python.

Problèmes courants

« Error: path does not exist » / fichier introuvable. read_excel("data.xlsx") cherche dans votre répertoire de travail courant. Vérifiez-le avec getwd(), donnez un chemin complet, ou utilisez read_excel(file.choose()) pour choisir le fichier de façon interactive.

Vous avez lu la mauvaise feuille. Lire par index (sheet = 2) casse dès que les onglets sont réorganisés. Exécutez d’abord excel_sheets(path) et lisez par nom (sheet = "data") — c’est auto-documenté et stable.

Une colonne d’ID a perdu ses zéros de tête, ou des dates sont arrivées sous forme de nombres. readxl devine les types d’après les données, et "00123" paraît numérique. Forcez l’analyse avec col_types = — "text" pour les ID, "date" pour les dates — pour que les valeurs survivent à l’import.

library(xlsx) refuse de s’installer (erreurs Java). Les anciens packages xlsx/XLConnect ont besoin d’une chaîne d’outils Java (rJava) fonctionnelle et échouent sur de nombreuses machines. Vous n’en avez pas besoin — readxl (lecture) et openxlsx (lecture + écriture) sont en pur R/C++ et s’installent proprement.

Questions fréquentes

NoteComment lire un fichier Excel dans R ?

Installez et chargez readxl, puis appelez read_excel("file.xlsx") — il renvoie la feuille sous forme de tibble et fonctionne pour .xls comme pour .xlsx. Pour lire un onglet précis, ajoutez sheet = "name" (ou un numéro). Aucun Java ni autre logiciel externe n’est requis.

NoteQuelle est la différence entre read_excel et read.xlsx ?

readxl::read_excel() lit à la fois .xls et .xlsx, renvoie un tibble et est la valeur par défaut moderne pour lire. openxlsx::read.xlsx() ne lit que les .xlsx, renvoie un data frame simple, et sait aussi écrire et styliser les classeurs. Tous deux évitent la dépendance Java de l’ancien package xlsx — choisissez readxl pour lire, openxlsx si vous devez aussi écrire.

NoteComment lire une feuille ou une plage précise d’un fichier Excel ?

Listez les onglets avec excel_sheets("file.xlsx"), puis lisez-en un avec read_excel("file.xlsx", sheet = "Sheet2") (par nom) ou sheet = 2 (par position). Pour une partie d’une feuille, utilisez le style Excel range = "B2:D20", ou supprimez les premières lignes avec skip = 3.

NoteComment lire des fichiers xls et xlsx dans R ?

read_excel() gère les deux automatiquement — il détecte le format d’après l’extension du fichier, si bien que le même appel lit report.xls et report.xlsx. Le read.xlsx() d’openxlsx ne lit que les .xlsx ; pour un fichier .xls hérité, utilisez readxl.

NoteFaut-il utiliser le package xlsx pour lire des fichiers Excel ?

Non. Les packages xlsx et XLConnect sont basés sur Java et échouent souvent à s’installer (problèmes rJava/JDK). Utilisez readxl pour la lecture et openxlsx pour la lecture + l’écriture — tous deux sont en pur R/C++, plus rapides, et s’installent sans configuration supplémentaire.

Testez vos connaissances

ImportantExercice : lister, puis lire une feuille nommée

Écrivez un classeur à deux feuilles (iris en "flowers", mtcars en "cars"), listez ses feuilles, puis lisez uniquement la feuille "cars" — et confirmez que vous avez la bonne avec names().

# write_xlsx takes a NAMED list: list(flowers = ..., cars = ...)
# read_excel selects a tab with sheet = "cars"

library(writexl) library(readxl) path <- tempfile(fileext = ".xlsx") write_xlsx(list(flowers = head(iris, 5), cars = head(mtcars[, 1:3], 4)), path) excel_sheets(path) cars <- read_excel(path, sheet = "cars") names(cars) # mpg, cyl, disp

library(writexl)
library(readxl)

path <- tempfile(fileext = ".xlsx")
write_xlsx(list(flowers = head(iris, 5), cars = head(mtcars[, 1:3], 4)), path)

excel_sheets(path)

cars <- read_excel(path, sheet = "cars")
names(cars)   # mpg, cyl, disp

NoteVérification rapide : quel appel lit la deuxième feuille ?

Un classeur a les onglets "raw" et "clean". Vous voulez "clean". Quel est l’appel le plus robuste ?

A. read_excel("wb.xlsx") B. read_excel("wb.xlsx", sheet = 2) C. read_excel("wb.xlsx", sheet = "clean")

Afficher la réponse

C. Lire par nom est robuste — cela fonctionne encore si les onglets sont réorganisés. A lit la première feuille ("raw"). B lit la deuxième par position, ce qui lit silencieusement le mauvais onglet dès que quelqu’un déplace une feuille. Exécutez d’abord excel_sheets("wb.xlsx"), puis lisez par nom.

Conclusion

Lire un fichier Excel dans R tient en une ligne avec readxl : read_excel("file.xlsx"). Ajoutez excel_sheets() pour trouver le bon onglet, sheet =/range =/skip = pour cibler un bloc, et col_types =/na = pour corriger l’analyse. Tournez-vous vers openxlsx quand le même script doit aussi écrire un classeur, et laissez entièrement de côté le package xlsx basé sur Java.

Leçons connexes

• Écrire des fichiers Excel en R — exportez un ou plusieurs data frames vers .xlsx. · Lire des fichiers CSV et texte en R — la voie readr / base-R pour les fichiers plats. · Sauvegarder RDS et RData — stockez des objets R natifs pour un rechargement instantané. · Exporter des données depuis R — la vue d’ensemble complète pour faire sortir vos données.
• Pour aller plus loin : Importer et exporter des données — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Importer et exporter des données en R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.