Lesen Sie eine Excel-Datei direkt aus einem R-Skript

Wie kann ich eine Excel-Datei direkt in R lesen? Oder sollte ich zuerst die Daten in eine Text- oder CSV-Datei exportieren und diese Datei in R importieren?

Ja. Siehe die entsprechende Seite im R-Wiki . Kurze Antwort: read.xlsDas gdataPaket funktioniert die meiste Zeit (obwohl Perl auf Ihrem System installiert sein muss - normalerweise bereits unter MacOS und Linux, aber unter Windows ein zusätzlicher Schritt, siehe http://strawberryperl.com/). ). Auf der R-Wiki-Seite sind verschiedene Vorbehalte und Alternativen aufgeführt.

Der einzige Grund, warum ich dies nicht direkt sehe, ist, dass Sie die Tabelle möglicherweise untersuchen möchten, um festzustellen, ob sie Störungen aufweist (seltsame Überschriften, mehrere Arbeitsblätter [Sie können jeweils nur eine lesen, obwohl Sie offensichtlich alle durchlaufen können] , einschließlich Grundstücke usw.). Aber für eine wohlgeformte, rechteckige Tabelle mit einfachen Zahlen und Zeichendaten (dh nicht durch Kommas formatierten Zahlen, Datumsangaben, Formeln mit Fehlern beim Teilen durch Null, fehlenden Werten usw. usw.) habe ich im Allgemeinen kein Problem mit diesem Prozess.

Lassen Sie mich noch einmal wiederholen, was @Chase empfohlen hat: Verwenden Sie XLConnect .

Die Gründe für die Verwendung von XLConnect sind meiner Meinung nach:

1. Plattformübergreifend. XLConnect ist in Java geschrieben und kann daher unter Win, Linux, Mac ohne Änderung Ihres R-Codes ausgeführt werden (außer möglicherweise Pfadzeichenfolgen).
2. Sonst nichts zu laden. Installieren Sie einfach XLConnect und fahren Sie mit dem Leben fort.
3. Sie haben nur das Lesen von Excel-Dateien erwähnt, aber XLConnect schreibt auch Excel-Dateien, einschließlich der Änderung der Zellenformatierung. Und das unter Linux oder Mac, nicht nur unter Win.

XLConnect ist im Vergleich zu anderen Lösungen etwas neu und wird daher in Blog-Posts und Referenzdokumenten seltener erwähnt. Für mich war es sehr nützlich.

Und jetzt gibt es readxl :

Das readxl-Paket erleichtert das Abrufen von Daten aus Excel in R. Im Vergleich zu den vorhandenen Paketen (z. B. gdata, xlsx, xlsReadWrite usw.) weist readxl keine externen Abhängigkeiten auf, sodass die Installation und Verwendung auf allen Betriebssystemen einfach ist. Es wurde entwickelt, um mit tabellarischen Daten zu arbeiten, die in einem einzigen Blatt gespeichert sind.

readxl basiert auf der libxls C-Bibliothek, die viele der Komplexitäten des zugrunde liegenden Binärformats abstrahiert.

Es unterstützt sowohl das ältere XLS-Format als auch XLSX

readxl ist bei CRAN erhältlich, oder Sie können es von github installieren mit:

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

Verwendung

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")

Beachten Sie, dass in der Beschreibung zwar "keine externen Abhängigkeiten" angegeben ist, jedoch das RcppPaket erforderlich ist , für das wiederum Rtools (für Windows) oder Xcode (für OSX) erforderlich sind , die Abhängigkeiten außerhalb von R sind. Viele Benutzer haben sie jedoch aus anderen Gründen installiert .

EDIT 2015-Oktober: Wie andere hier kommentiert haben, sind die openxlsxund readxl-Pakete bei weitem schneller als das xlsxPaket und schaffen es tatsächlich, größere Excel-Dateien (> 1500 Zeilen &> 120 Spalten) zu öffnen. @MichaelChirico zeigt, dass dies readxlbesser ist, wenn Geschwindigkeit bevorzugt wird, und openxlsxersetzt die vom xlsxPaket bereitgestellten Funktionen . Wenn Sie nach einem Paket zum Lesen, Schreiben und Ändern von Excel-Dateien im Jahr 2015 suchen, wählen Sie das openxlsxanstelle von xlsx.

Vor 2015: Ich habe xlsxPaket verwendet . Es hat meinen Workflow mit Excel und R geändert. Keine nervigen Popups mehr, die fragen, ob ich sicher bin, dass ich meine Excel-Tabelle im TXT-Format speichern möchte. Das Paket schreibt auch Excel-Dateien.

Allerdings finde ich die read.xlsxFunktion beim Öffnen großer Excel-Dateien langsam. read.xlsx2Die Funktion ist erheblich schneller, stellt jedoch die Vektorklasse der data.frame-Spalten nicht in Frage. Sie müssen den colClassesBefehl verwenden, um die gewünschten Spaltenklassen anzugeben, wenn Sie die read.xlsx2Funktion verwenden. Hier ist ein praktisches Beispiel:

read.xlsx("filename.xlsx", 1)Liest Ihre Datei und macht die Spaltenklassen data.frame nahezu nützlich, ist jedoch für große Datenmengen sehr langsam. Funktioniert auch für .xlsDateien.

read.xlsx2("filename.xlsx", 1)ist schneller, aber Sie müssen Spaltenklassen manuell definieren. Eine Verknüpfung besteht darin, den Befehl zweimal auszuführen (siehe das folgende Beispiel). characterDie Spezifikation konvertiert Ihre Spalten in Faktoren. Verwendung Dateund POSIXctOptionen für die Zeit.

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)))

Angesichts der RVielzahl unterschiedlicher Möglichkeiten zum Einlesen einer Excel-Datei und der Vielzahl von Antworten hier dachte ich, ich würde versuchen, etwas Licht ins Dunkel zu bringen, welche der hier genannten Optionen (in einigen einfachen Situationen) die beste Leistung erbringt.

Ich selbst habe es verwendet, xlsxseit ich angefangen habe R, für Trägheit, wenn nichts anderes, und ich habe kürzlich bemerkt, dass es keine objektiven Informationen darüber zu geben scheint, welches Paket besser funktioniert.

Jede Benchmarking-Übung ist mit Schwierigkeiten behaftet, da einige Pakete bestimmte Situationen mit Sicherheit besser bewältigen als andere und ein Wasserfall mit anderen Einschränkungen.

Trotzdem verwende ich einen (reproduzierbaren) Datensatz, der meiner Meinung nach in einem ziemlich gebräuchlichen Format vorliegt (8 Zeichenfolgenfelder, 3 numerische, 1 Ganzzahl, 3 Datumsangaben):

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)
)

Ich schrieb dann diese zu csv und eröffnen in Libreoffice und speicherte es als XLSX - Datei, dann gebenchmarkt 4 der in diesem Thread erwähnten Pakete: xlsx, openxlsx, readxl, und gdata, um die Standardoptionen (Ich habe auch versucht , eine Version von , ob ich Geben Sie die Spaltentypen an, dies hat jedoch die Rangfolge nicht geändert.

Ich schließe aus, RODBCweil ich unter Linux bin. XLConnectweil es den Anschein hat, dass sein Hauptzweck nicht darin besteht, einzelne Excel-Tabellen zu lesen, sondern ganze Excel-Arbeitsmappen zu importieren, scheint es unfair, sein Pferd nur mit seinen Lesefähigkeiten ins Rennen zu bringen; und xlsReadWriteweil es nicht mehr mit meiner Version von kompatibel ist R(scheint auslaufen).

Ich habe dann Benchmarks mit NN=1000Lund NN=25000L(Zurücksetzen des Startwerts vor jeder Deklaration der data.frameoben genannten) ausgeführt, um Unterschiede in Bezug auf die Größe der Excel-Datei zu berücksichtigen. gcist in erster Linie für xlsx, die ich manchmal gefunden habe, kann Speicher Clogs erstellen. Hier sind ohne weiteres die Ergebnisse, die ich gefunden habe:

Excel-Datei mit 1.000 Zeilen

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 readxlist der Gewinner, mit openxlsxwettbewerbsfähigem und gdataklarem Verlierer. Nehmen Sie jede Maßnahme relativ zum Spaltenminimum:

#       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

Wir sehen meinen eigenen Favoriten, xlsxist 60% langsamer als readxl.

Excel-Datei mit 25.000 Zeilen

Aufgrund des Zeitaufwands habe ich nur 20 Wiederholungen für die größere Datei durchgeführt, ansonsten waren die Befehle identisch. Hier sind die Rohdaten:

# 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

Hier sind die relativen Daten:

#       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 readxlist der klare Gewinner, wenn es um Geschwindigkeit geht. gdataEs ist besser, etwas anderes zu tun, da das Lesen von Excel-Dateien schmerzhaft langsam ist und dieses Problem nur bei größeren Tabellen noch verstärkt wird.

Zwei Draws von openxlsxsind 1) seine umfangreichen anderen Methoden ( readxlist darauf ausgelegt, nur eine Sache zu tun, was wahrscheinlich ein Teil dessen ist, warum es so schnell ist), insbesondere seine write.xlsxFunktion, und 2) (eher ein Nachteil für readxl) das col_typesArgument in readxlnur (as dieses Schreibens) akzeptiert einige nicht standardmäßige R: "text"anstelle von "character"und "date"anstelle von "Date".

Ich hatte viel Glück mit 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)

Persönlich mag ich RODBC und kann es empfehlen.

Ich habe das Paket openxlsxheute ausprobiert. Es hat sehr gut (und schnell) funktioniert.

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

Eine andere Lösung ist das xlsReadWritePaket, für das keine zusätzlichen Installationen erforderlich sind. Sie müssen jedoch die zusätzliche shlib herunterladen, bevor Sie sie zum ersten Mal verwenden.

require(xlsReadWrite)
xls.getshlib()

Wenn Sie dies vergessen, kann dies zu völliger Frustration führen. War schon da und so ...

Nebenbemerkung: Möglicherweise möchten Sie in ein textbasiertes Format (z. B. CSV) konvertieren und von dort aus einlesen. Dies aus einer Reihe von Gründen:

• Unabhängig von Ihrer Lösung (RODBC, gdata, xlsReadWrite) können bei der Konvertierung Ihrer Daten einige seltsame Dinge passieren. Besonders Daten können ziemlich umständlich sein. Das HFWutilsPaket enthält einige Tools für den Umgang mit EXCEL-Daten (gemäß dem Kommentar von @Ben Bolker).

• Wenn Sie große Blätter haben, ist das Einlesen von Textdateien schneller als das Einlesen von EXCEL.

• Für XLS- und XLSX-Dateien sind möglicherweise unterschiedliche Lösungen erforderlich. ZB unterstützt das xlsReadWrite-Paket derzeit keine .xlsx AFAIK. gdataerfordert die Installation zusätzlicher Perl-Bibliotheken für die XLSX-Unterstützung. xlsxDas Paket kann gleichnamige Erweiterungen verarbeiten.

Wie oben in vielen anderen Antworten erwähnt, gibt es viele gute Pakete, die eine Verbindung zur XLS / X-Datei herstellen und die Daten auf vernünftige Weise abrufen. Sie sollten jedoch gewarnt werden, dass Sie unter keinen Umständen die Zwischenablage (oder eine CSV-Datei) zum Abrufen von Daten aus Excel verwenden sollten. Um zu sehen warum, geben Sie =1/3eine Zelle in Excel ein. Reduzieren Sie nun die Anzahl der für Sie sichtbaren Dezimalstellen auf zwei. Kopieren Sie dann die Daten und fügen Sie sie in R ein. Speichern Sie nun die CSV. Sie werden feststellen, dass Excel in beiden Fällen nur die Daten beibehalten hat, die für Sie über die Benutzeroberfläche sichtbar waren, und dass Sie die Genauigkeit Ihrer tatsächlichen Quelldaten verloren haben.

Wenn Sie die Antwort von @Mikko erweitern, können Sie einen ordentlichen Trick verwenden, um die Dinge zu beschleunigen, ohne Ihre Spaltenklassen im Voraus "kennen" zu müssen. Verwenden Sie einfach read.xlsx, um eine begrenzte Anzahl von Datensätzen abzurufen, um die Klassen zu bestimmen, und folgen Sie dann mitread.xlsx2

Beispiel

# 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)))

Eine Excel-Datei kann wie folgt direkt in R eingelesen werden:

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

Lesen von xls- und xlxs-Dateien mit dem readxl-Paket

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