Lire un fichier Excel directement à partir D'un script R

permettez-moi de répéter ce que @Chase a recommandé: utilisez XLConnect .

les raisons d'utiliser XLConnect sont, à mon avis:

1. de la Croix-plate-forme. XLConnect est écrit en Java et, donc, s'exécute sur Win, Linux, Mac sans changement de votre code R (sauf éventuellement les chaînes de chemins)
2. Rien d'autre à charger. Il suffit d'installer XLConnect et de passer à la vie.
3. Vous n' mentionné la lecture des fichiers Excel, mais XLConnect écrira également des fichiers Excel, y compris le changement de la mise en forme des cellules. Et il le fera à partir de Linux ou Mac, pas seulement gagner.

XLConnect est quelque peu nouveau par rapport à d'autres solutions, il est donc moins souvent mentionné dans les billets de blog et les documents de référence. Pour moi, ça a été très utile.

et maintenant il y a readxl :

le paquet readxl rend facile d'obtenir des données à partir D'Excel et dans R. Par rapport aux paquets existants (par exemple gdata, xlsx, xlsReadWrite, etc.)) readxl n'a pas de dépendances externes, il est donc facile de l'installer et de l'utiliser tous les systèmes d'exploitation. Il est conçu pour fonctionner avec des données tabulaires stockées dans une seule feuille.

readxl est construit sur la bibliothèque libxls C, qui résumés loin beaucoup des complexités du format binaire sous-jacent.

il supporte les deux héritages .format xls et .xlsx

readxl est disponible chez CRAN, ou vous pouvez l'installer chez github avec:

# install.packages("devtools")
devtools::install_github("hadley/readxl")

Utilisation

library(readxl)

# read_excel reads both xls and xlsx files
read_excel("my-old-spreadsheet.xls")
read_excel("my-new-spreadsheet.xlsx")

# Specify sheet with a number or name
read_excel("my-spreadsheet.xls", sheet = "data")
read_excel("my-spreadsheet.xls", sheet = 2)

# If NAs are represented by something other than blank cells,
# set the na argument
read_excel("my-spreadsheet.xls", na = "NA")

notez que bien que la description indique "aucune dépendance externe", elle nécessite le paquet Rcpp , qui à son tour nécessite Rtools (Pour Windows) ou Xcode (pour OSX), qui sont dépendances externes à R. Bien que beaucoup de gens les ont installés pour d'autres raisons.

modifier 2015-octobre: comme d'autres l'ont commenté ici, les paquets openxlsx et readxl sont de loin plus rapides que le paquet xlsx et parviennent en fait à ouvrir des fichiers Excel plus grands (>1500 lignes & > 120 colonnes). @MichaelChirico démontre que readxl est meilleur quand la vitesse est préférée et openxlsx remplace la fonctionnalité fournie par le paquet xlsx . Si vous êtes à la recherche d'un paquet pour lire, écrire et modifier les fichiers Excel en 2015, choisissez le openxlsx au lieu de xlsx .

Pré-2015: j'ai utilisé xlsx package . Il a changé mon workflow avec Excel et R. plus de pop-ups ennuyeux demandant, si je suis sûr que je veux sauver ma feuille D'Excel .format txt. Le paquet écrit aussi des fichiers Excel.

cependant, je trouve la fonction read.xlsx lente, lors de l'ouverture de grands fichiers Excel. La fonction read.xlsx2 est considérablement plus rapide, mais ne change pas la classe de données vectorielles.cadre de colonnes. Vous devez utiliser la commande colClasses pour spécifier les classes de colonne désirées, si vous utilisez la fonction read.xlsx2 . Voici un exemple pratique:

read.xlsx("filename.xlsx", 1) lit votre fichier et fait les données.les classes de colonnes de cadre sont presque utiles, mais elles sont très lentes pour les grands ensembles de données. Fonctionne aussi pour les fichiers .xls .

read.xlsx2("filename.xlsx", 1) est plus rapide, mais vous devrez définir les classes de colonne manuellement. Un raccourci pour exécuter la commande deux fois (voir l'exemple ci-dessous). La spécification character convertit vos colonnes en facteurs. Utilisez les options Date et POSIXct pour le temps.

coln <- function(x){y <- rbind(seq(1,ncol(x))); colnames(y) <- colnames(x)
rownames(y) <- "col.number"; return(y)} # A function to see column numbers

data <- read.xlsx2("filename.xlsx", 1) # Open the file 

coln(data)    # Check the column numbers you want to have as factors

x <- 3 # Say you want columns 1-3 as factors, the rest numeric

data <- read.xlsx2("filename.xlsx", 1, colClasses= c(rep("character", x),
rep("numeric", ncol(data)-x+1)))

étant donné la prolifération de différentes façons de lire un fichier Excel dans R et la pléthore de réponses ici, j'ai pensé que je voudrais essayer de faire la lumière sur laquelle des options mentionnées ici effectuer le meilleur (dans quelques situations simples).

j'ai moi-même utilisé xlsx depuis que j'ai commencé à utiliser R , pour l'inertie si rien d'autre, et j'ai récemment remarqué qu'il ne semble pas y avoir d'informations objectives sur Quel paquet fonctionne le mieux.

tout exercice de benchmarking est semé de difficultés car certains paquets sont sûrs de gérer certaines situations mieux que d'autres, et une cascade d'autres caveats.

cela dit, je suis à l'aide d'un (reproductible) ensemble de données qui, je pense, est dans un joli format commun (8 champs de type chaîne, 3 numérique, 1 entier, 3 dates):

set.seed(51423)
data.frame(
  str1 = sample(sprintf("%010d", 1:NN)), #ID field 1
  str2 = sample(sprintf("%09d", 1:NN)),  #ID field 2
  #varying length string field--think names/addresses, etc.
  str3 = 
    replicate(NN, paste0(sample(LETTERS, sample(10:30, 1L), TRUE),
                         collapse = "")),
  #factor-like string field with 50 "levels"
  str4 = sprintf("%05d", sample(sample(1e5, 50L), NN, TRUE)),
  #factor-like string field with 17 levels, varying length
  str5 = 
    sample(replicate(17L, paste0(sample(LETTERS, sample(15:25, 1L), TRUE),
                                 collapse = "")), NN, TRUE),
  #lognormally distributed numeric
  num1 = round(exp(rnorm(NN, mean = 6.5, sd = 1.5)), 2L),
  #3 binary strings
  str6 = sample(c("Y","N"), NN, TRUE),
  str7 = sample(c("M","F"), NN, TRUE),
  str8 = sample(c("B","W"), NN, TRUE),
  #right-skewed integer
  int1 = ceiling(rexp(NN)),
  #dates by month
  dat1 = 
    sample(seq(from = as.Date("2005-12-31"), 
               to = as.Date("2015-12-31"), by = "month"),
           NN, TRUE),
  dat2 = 
    sample(seq(from = as.Date("2005-12-31"), 
               to = as.Date("2015-12-31"), by = "month"),
           NN, TRUE),
  num2 = round(exp(rnorm(NN, mean = 6, sd = 1.5)), 2L),
  #date by day
  dat3 = 
    sample(seq(from = as.Date("2015-06-01"), 
               to = as.Date("2015-07-15"), by = "day"),
           NN, TRUE),
  #lognormal numeric that can be positive or negative
  num3 = 
    (-1) ^ sample(2, NN, TRUE) * round(exp(rnorm(NN, mean = 6, sd = 1.5)), 2L)
)

j'ai alors écrit ceci à csv et ouvert dans LibreOffice et l'ai sauvé comme un .fichier xlsx, puis référencé 4 des paquets mentionnés dans ce thread: xlsx , openxlsx , readxl , et gdata , en utilisant les options par défaut (j'ai aussi essayé une version de si oui ou non je spécifie les types de colonne, mais cela n'a pas changé le classement).

j'exclus RODBC parce que je suis sur Linux; XLConnect parce qu'il semble que son but premier n'est pas de lire dans des feuilles D'Excel mais d'importer des classeurs Excel entiers, donc de mettre son cheval dans la course sur seulement ses capacités de lecture semble injuste; et xlsReadWrite car il n'est plus compatible avec ma version de R (semble avoir été éliminée).

j'ai ensuite lancé des benchmarks avec NN=1000L et NN=25000L (réinitialisation de la graine avant chaque déclaration du data.frame ci-dessus) pour tenir compte des différences par rapport à la taille du fichier Excel. gc est principalement pour xlsx , que j'ai trouvé parfois peut créer des sabots de mémoire. Sans plus ado, voici les résultats que j'ai trouvés:

De 1 000 Ligne Fichier Excel

benchmark1k <-
  microbenchmark(times = 100L,
                 xlsx = {xlsx::read.xlsx2(fl, sheetIndex=1); invisible(gc())},
                 openxlsx = {openxlsx::read.xlsx(fl); invisible(gc())},
                 readxl = {readxl::read_excel(fl); invisible(gc())},
                 gdata = {gdata::read.xls(fl); invisible(gc())})

# Unit: milliseconds
#      expr       min        lq      mean    median        uq       max neval
#      xlsx  194.1958  199.2662  214.1512  201.9063  212.7563  354.0327   100
#  openxlsx  142.2074  142.9028  151.9127  143.7239  148.0940  255.0124   100
#    readxl  122.0238  122.8448  132.4021  123.6964  130.2881  214.5138   100
#     gdata 2004.4745 2042.0732 2087.8724 2062.5259 2116.7795 2425.6345   100

So readxl est le gagnant, avec openxlsx compétitif et gdata un perdant clair. En prenant chaque mesure par rapport à la colonne minimum:

#       expr   min    lq  mean median    uq   max
# 1     xlsx  1.59  1.62  1.62   1.63  1.63  1.65
# 2 openxlsx  1.17  1.16  1.15   1.16  1.14  1.19
# 3   readxl  1.00  1.00  1.00   1.00  1.00  1.00
# 4    gdata 16.43 16.62 15.77  16.67 16.25 11.31

nous voyons mon préféré, xlsx est 60% plus lent que readxl .

De 25 000 Rangée Fichier Excel

en raison du montant de le temps que ça prend, je n'ai fait que 20 répétitions sur le gros fichier, sinon les commandes étaient identiques. Voici les données brutes:

# Unit: milliseconds
#      expr        min         lq       mean     median         uq        max neval
#      xlsx  4451.9553  4539.4599  4738.6366  4762.1768  4941.2331  5091.0057    20
#  openxlsx   962.1579   981.0613   988.5006   986.1091   992.6017  1040.4158    20
#    readxl   341.0006   344.8904   347.0779   346.4518   348.9273   360.1808    20
#     gdata 43860.4013 44375.6340 44848.7797 44991.2208 45251.4441 45652.0826    20

Voici les données relatives:

#       expr    min     lq   mean median     uq    max
# 1     xlsx  13.06  13.16  13.65  13.75  14.16  14.13
# 2 openxlsx   2.82   2.84   2.85   2.85   2.84   2.89
# 3   readxl   1.00   1.00   1.00   1.00   1.00   1.00
# 4    gdata 128.62 128.67 129.22 129.86 129.69 126.75

So readxl est le vainqueur clair quand il s'agit de vitesse. gdata vaudrait mieux avoir quelque chose d'autre pour elle, car il est douloureusement lent à lire les fichiers Excel, et ce problème est exacerbé que pour les grandes tables.

deux tirages de openxlsx sont: 1) de son étendue à d'autres méthodes ( readxl est conçu pour faire seulement une chose, ce qui est probablement en partie pourquoi il est si rapide), notamment son write.xlsx de la fonction, et 2) (en plus d'un inconvénient pour readxl ) le col_types argument readxl seulement (comme d'écrire ces lignes) accepte certains non standard R : "text" au lieu de "character" et "date" au lieu de "Date" .

j'ai eu de la chance avec XLConnect : http://cran.r-project.org/web/packages/XLConnect/index.html

library(RODBC)
file.name <- "file.xls"
sheet.name <- "Sheet Name"

## Connect to Excel File Pull and Format Data
excel.connect <- odbcConnectExcel(file.name)
dat <- sqlFetch(excel.connect, sheet.name, na.strings=c("","-"))
odbcClose(excel.connect)

personnellement, J'aime RODBC et je peux le recommander.

vient D'essayer le paquet openxlsx aujourd'hui. Il a vraiment bien travaillé (et rapide).

http://cran.r-project.org/web/packages/openxlsx/index.html

une autre solution est le xlsReadWrite paquet, qui ne nécessite pas d'installation supplémentaire, mais exige que vous téléchargez le shlib supplémentaire avant de l'utiliser la première fois par:

require(xlsReadWrite)
xls.getshlib()

oublier cela peut causer une frustration totale. Été là et tout ça...

sur un sidenote : vous pourriez vouloir convertir en format texte (par exemple csv) et lire à partir de là. Ce pour un certain nombre de raisons :

• quelle que soit votre solution (RODBC, GDATA, xlsReadWrite) certaines choses étranges peuvent se produire lorsque vos données sont converties. Surtout les dates peuvent être assez encombrantes. Le paquet HFWutils a quelques outils pour gérer les dates EXCEL (commentaire de @Ben Bolker).

• si vous avez de grandes feuilles, la lecture dans les fichiers texte est plus rapide que la lecture dans EXCEL.

• for .xls et .fichiers xlsx, différentes solutions peuvent être nécessaires. Par exemple, le paquet xlsReadWrite n'est actuellement pas supporté .xlsx autant que je sache. gdata nécessite l'installation de bibliothèques perl supplémentaires pour .xlsx de soutien. Le paquet xlsx peut traiter des extensions du même nom.

comme indiqué ci-dessus dans beaucoup d'autres réponses, il y a beaucoup de bons paquets qui se connectent au fichier XLS/X et obtiennent les données d'une manière raisonnable. Cependant, vous devez être averti qu'en aucun cas vous ne devez utiliser le presse-papiers (ou une .csv) pour extraire des données à partir D'Excel. Pour comprendre pourquoi, entrez =1/3 dans une cellule dans excel. Maintenant, réduisez le nombre de points décimaux visibles à deux. Puis copier et coller les données dans R. maintenant enregistrer le CSV. Vous remarquerez que dans les deux cas Excel n'a gardé que les données qui étaient visibles à travers l'interface et vous avez perdu toute la précision de vos données source réelles.

en développant sur la réponse fournie par @Mikko vous pouvez utiliser un tour soigné pour accélérer les choses sans avoir à "connaître" vos classes de colonne à l'avance. Il suffit d'utiliser read.xlsx pour saisir un nombre limité d'enregistrements pour déterminer les classes, puis suivi par read.xlsx2

exemple

# just the first 50 rows should do...
df.temp <- read.xlsx("filename.xlsx", 1, startRow=1, endRow=50) 
df.real <- read.xlsx2("filename.xlsx", 1, 
                      colClasses=as.vector(sapply(df.temp, mode)))

un fichier Excel peut être lu directement dans R comme suit:

my_data <- read.table(file = "xxxxxx.xls", sep = "\t", header=TRUE)

lecture des fichiers xls et xlxs à l'aide du paquet readxl

library("readxl")
my_data <- read_excel("xxxxx.xls")
my_data <- read_excel("xxxxx.xlsx")