Lire des fichiers Excel en R (readxl)

R a besoin d'un package pour lire les fichiers Excel

R de base lit les formats texte d'emblée, mais .xlsx n'est pas du texte - c'est un ensemble de XML compressé, et .xls avant lui était un format binaire. Il n'y a aucun read.xlsx() intégré qui t'attend. Pour ouvrir des fichiers Excel tu installes un package, et le choix standard est readxl : il lit à la fois .xlsx et .xls, n'a aucune dépendance externe (ni Java, ni installation d'Excel nécessaire), et fait bien une seule chose.

install.packages("readxl")   # once per machine
library(readxl)              # once per session

Les extraits de cette page nécessitent readxl installé localement, ils sont donc présentés en code statique plutôt qu'en blocs exécutables - lance-les dans ta propre session R. Si les packages sont nouveaux pour toi, la version courte : install.packages() le télécharge une fois, library() le charge à chaque démarrage de R.

read_excel() : les bases

Un appel lit la première feuille d'un classeur dans R :

library(readxl)

sales <- read_excel("sales.xlsx")
head(sales)
str(sales)

Mêmes habitudes que pour tout import : str() pour vérifier le type de chaque colonne, head() pour jeter un œil aux premières lignes. Si le fichier n'est pas trouvé, la cause est presque toujours le répertoire de travail - file.exists("sales.xlsx") te le dit en une seconde, et la correction est la même que pour les fichiers CSV : utilise un chemin complet ou fixe le répertoire de travail au dossier du fichier.

Ce qui revient est un tibble - la version tidyverse du data frame. Pour tout ce que tu feras en débutant, il se comporte exactement comme un data frame (c'en est un, avec des extras) : $ extrait les colonnes, nrow() compte les lignes, il s'écoule dans les verbes dplyr. Les différences visibles sont cosmétiques et agréables - il n'affiche que les dix premières lignes avec les types de colonnes sous les noms, au lieu de tout déverser. Si une fonction plus ancienne exige un data frame ordinaire, as.data.frame(sales) convertit.

Choisir des feuilles, des plages, et sauter le superflu

Les vrais classeurs sont rarement un tableau propre commençant en cellule A1. Les arguments de readxl gèrent le désordre habituel.

Quelles feuilles existent ? Demande avant de lire :

excel_sheets("report.xlsx")
# [1] "Summary"  "Q1"  "Q2"  "Q3"  "Raw data"

sheet = en choisit une, par nom ou par position :

q3 <- read_excel("report.xlsx", sheet = "Q3")
raw <- read_excel("report.xlsx", sheet = 5)

Préfère le nom - sheet = 5 lit silencieusement la mauvaise feuille le jour où quelqu'un réordonne les onglets.

range = lit un rectangle exact, dans la notation propre à Excel. C'est la façon la plus propre de sauter les lignes de logo, les lignes de titre et les notes égarées autour du vrai tableau :

budget <- read_excel("budget.xlsx", range = "B4:E20")
budget <- read_excel("budget.xlsx", sheet = "Plan", range = "B4:E20")

skip = et col_names = sont l'alternative plus souple quand tu sais combien de lignes parasites se trouvent au-dessus des données mais pas où elles se terminent :

# Data starts after 3 title rows, first real row is the header:
df <- read_excel("export.xlsx", skip = 3)

# No header row at all - supply names yourself:
df <- read_excel("export.xlsx", col_names = c("id", "region", "amount"))

col_names = TRUE (la valeur par défaut) utilise la première ligne comme noms ; FALSE génère ...1, ...2 et traite la ligne un comme des données.

Écrire de l'Excel demande un autre package

readxl est en lecture seule par conception. Quand un collègue veut tes résultats sous forme de tableur, la route la plus rapide est writexl - une seule ligne sans dépendances :

install.packages("writexl")
writexl::write_xlsx(results, "results.xlsx")

Si tu as besoin de plus que des valeurs brutes - en-têtes en gras, volets figés, couleurs de cellules, plusieurs feuilles mises en forme dans un classeur - tu es dans le territoire d'openxlsx :

library(openxlsx)
write.xlsx(list(Summary = summary_df, Detail = detail_df), "report.xlsx")

Une liste nommée devient une feuille par élément. openxlsx sait aussi lire les fichiers Excel, tu le verras donc utilisé dans les deux sens dans la nature ; pour de la simple lecture, readxl reste l'outil le plus simple.

L'alternative pragmatique : exporter un CSV

Parfois la solution la moins astucieuse gagne. Si le classeur est ponctuel - quelqu'un t'a envoyé un tableur et il te faut les chiffres maintenant - ouvre-le dans Excel, utilise « Enregistrer sous » pour exporter la feuille en CSV, et lis-la avec l'outil que tu connais déjà :

df <- read.csv("sales.csv")

Pas de package, pas de noms de feuilles, pas de cellules fusionnées. Le déroulé complet est dans lire un CSV. Les compromis : tu perds les autres feuilles, tu aplatis l'information portée par la mise en forme (des couleurs de cellules qui « signifient » quelque chose - une mauvaise conception de données de toute façon), et l'export est une étape manuelle que quelqu'un oubliera quand le fichier source sera mis à jour. Pour un pipeline récurrent, lis directement le .xlsx ; pour un import unique, le CSV convient très bien, honnêtement.

Les pièges classiques de l'import Excel

Les fichiers Excel apportent des problèmes que les CSV n'ont pas, parce que les tableurs laissent les humains faire des choses que les tableaux ne devraient pas permettre.

Les dates arrivent en nombres. Excel stocke les dates comme un numéro de jour séquentiel, et si une colonne mélange les types ou a été formatée bizarrement, tu peux te retrouver avec 44688 là où tu attendais une date. readxl convertit généralement correctement les vraies cellules de date, mais quand tu récupères le nombre brut, convertis avec l'époque d'Excel - qui est 1899-12-30, pas 1970 :

as.Date(44688, origin = "1899-12-30")
# [1] "2022-05-07"

Les cellules fusionnées se défusionnent en blancs. Un en-tête fusionné sur trois colonnes revient sous forme d'une valeur et de deux cellules vides ; une étiquette de catégorie fusionnée sur dix lignes devient une valeur et neuf manquantes. readxl ne peut pas récupérer une intention qui n'existait que visuellement - attends-toi à combler ces trous toi-même après l'import.

Une seule cellule égarée transforme une colonne en texte. Les types de colonnes sont devinés à partir des données, donc un unique "n/a", une note tapée au milieu des nombres, ou une espace dans une cellule « vide » fait revenir toute la colonne en character. Un str() juste après la lecture l'attrape ; l'argument col_types (par exemple col_types = c("text", "numeric", "date")) tranche la question quand la devinette se trompe systématiquement.

Le thème : un tableur est une toile sur laquelle les gens dessinent, pas un tableau. Lis-le avec ta casquette de sceptique, lance str(), et vérifie quelques valeurs face à l'original avant de faire confiance à l'import.

Ce que tu retiens

• R de base ne sait pas lire le .xlsx - installe readxl, puis read_excel("file.xlsx").
• excel_sheets() liste le contenu d'un classeur ; sheet = (préfère les noms) en choisit une ; range = "B4:E20" découpe exactement le tableau que tu veux.
• Tu récupères un tibble - un data frame avec un affichage plus agréable.
• L'écriture passe par un autre package : writexl::write_xlsx() pour une sortie simple, openxlsx pour des classeurs mis en forme.
• Pour du ponctuel, exporter un CSV depuis Excel et utiliser read.csv() est un raccourci parfaitement respectable.
• Surveille les trois classiques : les dates en numéros de série (origine 1899-12-30), les cellules fusionnées devenant des blancs, et une seule mauvaise cellule tirant une colonne vers le texte.

Prochaine étape : l'autre sens - écrire tes data frames vers des fichiers CSV et RDS.