Einfache Möglichkeit, mehrere data.frame in mehrere Excel-Arbeitsblätter zu exportieren

85

Ich bin überrascht, dass es keine einfache Möglichkeit gibt, mehrere data.frame in mehrere Arbeitsblätter einer Excel-Datei zu exportieren. Ich habe xlsx- Paket ausprobiert , anscheinend kann es nur auf ein Blatt schreiben (altes Blatt überschreiben); Ich habe auch das WriteXLS- Paket ausprobiert , aber es gibt mir ständig Fehler ...

Meine Codestruktur sieht folgendermaßen aus: Standardmäßig wurden für jede Iteration der Ausgabedatenrahmen (tempTable) und der Blattname (sn) aktualisiert und in eine Registerkarte exportiert.

for (i in 2 : ncol(code)){ 
        ...
        tempTable <- ...
        sn <- ...
        WriteXLS("tempTable", ExcelFileName = "C:/R_code/../file.xlsx",
              SheetNames = sn);
}

Ich kann in mehrere Lebenslaufdateien exportieren, aber es muss eine einfache Möglichkeit geben, dies in Excel zu tun, oder?

Oger Magi
quelle
3
Sie sind falsch über xlsx . Es gibt eine createSheetFunktion, mit der Sie neue Blätter erstellen und dann in einer Schleife darauf schreiben können. Darüber hinaus werden die entsprechenden Funktionen in XLConnect vektorisiert, sodass eine Liste von Datenrahmen auf mehrere Blätter geschrieben werden kann.
Joran
@joran, createSheet wird mit addDataFrame verwendet, nicht write.xlsx? Ich habe das früher im Dokument gesehen, konnte aber den gesamten Prozess nicht herausfinden.
Ogre Magi

Antworten:

144

Sie können mit dem xlsxPaket auf mehrere Blätter schreiben . Sie müssen nur sheetNamefür jeden Datenrahmen einen anderen verwenden und Folgendes hinzufügen append=TRUE:

library(xlsx)
write.xlsx(dataframe1, file="filename.xlsx", sheetName="sheet1", row.names=FALSE)
write.xlsx(dataframe2, file="filename.xlsx", sheetName="sheet2", append=TRUE, row.names=FALSE)

Eine weitere Option, mit der Sie mehr Kontrolle über die Formatierung und die Position des Datenrahmens haben, besteht darin, alles im R / xlsx-Code zu erledigen und die Arbeitsmappe am Ende zu speichern. Zum Beispiel:

wb = createWorkbook()

sheet = createSheet(wb, "Sheet 1")

addDataFrame(dataframe1, sheet=sheet, startColumn=1, row.names=FALSE)
addDataFrame(dataframe2, sheet=sheet, startColumn=10, row.names=FALSE)

sheet = createSheet(wb, "Sheet 2")

addDataFrame(dataframe3, sheet=sheet, startColumn=1, row.names=FALSE)

saveWorkbook(wb, "My_File.xlsx")

Falls Sie es nützlich finden könnten, sind hier einige interessante Helferfunktionen , die es einfacher machen hinzuzufügen Formatierung, Metadaten und andere Funktionen Tabellen mit xlsx: http://www.sthda.com/english/wiki/r2excel-read-write -und-formatieren-einfach-Excel-Dateien-mit-R-Software

eipi10
quelle
xlsxkümmert sich nicht um die Zahlen in der ersten Reihe R dort setzen. openxlsxentferne sie.
Buhtz
1
Hinzufügen row.names=FALSE, um Zeilennamen zu entfernen.
Eipi10
@EcologyTom Ich wechselte von xlsxzu openxlsxeiner Weile zurück, wie ich es viel intuitiver finden und es vermeidet auch die Java - Abhängigkeit.
eipi10
Ja, die Java-Abhängigkeit hat mich gezwungen, denselben Wechsel vorzunehmen. Obwohl der Code etwas länger ist, ist er ziemlich einfach. Eine Methode mit openxlsxVersion 4.0 finden Sie in meiner ergänzenden Antwort unten.
EcologyTom
2
Bin ich es nur, oder schreibt Blatt 2 einfach über Blatt 1, wenn man diesen Code verwendet?
NewBee
88

Sie können die openxlsx-Bibliothek auch verwenden, um mehrere Datensätze in mehrere Blätter in einer einzigen Arbeitsmappe zu exportieren. Der Vorteil von openxlsx gegenüber xlsx besteht darin, dass openxlsx die Abhängigkeiten von Java-Bibliotheken entfernt.

Schreiben Sie eine Liste von data.frames in einzelne Arbeitsblätter, indem Sie Listennamen als Arbeitsblattnamen verwenden.

require(openxlsx)
list_of_datasets <- list("Name of DataSheet1" = dataframe1, "Name of Datasheet2" = dataframe2)
write.xlsx(list_of_datasets, file = "writeXLSX2.xlsx")
Syed
quelle
3
Ich habe diese Pakete verwendet und ich denke, das openxlsxist das schnellste wie sein C ++. XlConnectwird Ihren RAM essen. Vielleicht möchten Sie ein Benchmarking zwischen xlsxundopenxlsx
Hanjo Jo'burg Odendaal
2
Ein weiterer Vorteil dieses Pakets besteht darin, dass es sich um die R-Nummerierung in der ersten Reihe kümmert.
Buhtz
4
Danke, openxlsx::write.xlsxist der richtige Weg ... Ich habe 11 Blätter gespeichert, jedes mit einem Datenrahmen von 20.000 x 10, fertig ist ein paar Sekunden, während xlsx::write.xlsxich nach dem Anhängen des zweiten Blattes mitjava.lang.OutOfMemoryError: Java heap space
Djork
Ich musste den Parameter append=TRUEzu write.xlsx hinzufügen , damit mehrere Blätter gleichzeitig in eine Excel-Datei geschrieben wurden
mondano
Schön! Ich habe meine Liste als Teil einer Schleife erstellt und musste sie nur initialisieren ( list_of_dfs <- list()) und dann mit temp_key und temp_df füllen, die während der Schleife erstellt wurden ( list_of_dfs[[temp_key]] = temp_df). Es war auch sehr schnell schriftlich, trotz der 16 Blätter, die ich erstellen musste! Hat jemand Probleme mit dem Gedächtnis während der Erstellung gesehen?
Lionel Trebuchon
30

Es gibt eine neue Bibliothek in der Stadt von rOpenSci: writexl

Tragbarer, leichter Datenrahmen für den xlsx-Exporter basierend auf libxlsxwriter. Kein Java oder Excel erforderlich

Ich fand es besser und schneller als die obigen Vorschläge (Arbeiten mit der Entwicklerversion):

library(writexl)
sheets <- list("sheet1Name" = sheet1, "sheet2Name" = sheet2) #assume sheet1 and sheet2 are data frames
write_xlsx(sheets, "path/to/location")
Giora Simchoni
quelle
1
Vielen Dank! Dies funktionierte dort, wo openxlsx es nicht tat (ich kann rtools bei der Arbeit nicht installieren).
Affe
Welche Version verwenden Sie dafür? Der Standard-Cran-Download unterstützt (noch) nicht mehrere Blätter: 'Fehler in writexl :: write_xlsx (Liste (...: Argument x muss ein Datenrahmen oder eine Liste von Datenrahmen sein' '
JAD
Wie ich geschrieben habe, die Dev-Version.
Giora Simchoni
@JarkoDubbeldam: Ich habe meine von cran installiert und mehrere Blätter funktionieren für mich (R 3.3.0). Überprüfen Sie, ob die Objekte in Ihrer Liste data.frames sind.
Affe
Das ist einer, der wirklich funktioniert. xlsx konnte nicht in r installiert werden.
Cina
20

Viele gute Antworten hier, aber einige von ihnen sind etwas veraltet. Wenn Sie einer einzelnen Datei weitere Arbeitsblätter hinzufügen möchten, ist dies der Ansatz, den ich für mich finde. Aus Gründen der Übersichtlichkeit finden Sie hier den Workflow für openxlsxVersion 4.0

# Create a blank workbook
OUT <- createWorkbook()

# Add some sheets to the workbook
addWorksheet(OUT, "Sheet 1 Name")
addWorksheet(OUT, "Sheet 2 Name")

# Write the data to the sheets
writeData(OUT, sheet = "Sheet 1 Name", x = dataframe1)
writeData(OUT, sheet = "Sheet 2 Name", x = dataframe2)

# Export the file
saveWorkbook(OUT, "My output file.xlsx")

BEARBEITEN

Ich habe jetzt ein paar andere Antworten ausprobiert und ich mag @ Syed's wirklich sehr. Es nutzt nicht alle Funktionen von, openxlsxaber wenn Sie eine schnelle und einfache Exportmethode wünschen, ist dies wahrscheinlich die einfachste.

EcologyTom
quelle
8

Ich bin mit dem Paket nicht vertraut WriteXLS. Ich benutze im Allgemeinen XLConnect:

library(XLConnect)
##
newWB <- loadWorkbook(
  filename="F:/TempDir/tempwb.xlsx",
  create=TRUE)
##
for(i in 1:10){
  wsName <- paste0("newsheet",i)
  createSheet(
    newWB,
    name=wsName)
  ##
  writeWorksheet(
    newWB,
    data=data.frame(
      X=1:10,
      Dataframe=paste0("DF ",i)),
    sheet=wsName,
    header=TRUE,
    rownames=NULL)
}
saveWorkbook(newWB)

Dies kann sicherlich vektorisiert werden, wie oben von @joran erwähnt, aber nur um schnell dynamische Blattnamen zu generieren, habe ich eine forSchleife verwendet, um dies zu demonstrieren.

Ich habe das create=TRUEArgument in verwendet, loadWorkbookseit ich eine neue XLSX-Datei erstellt habe. Wenn Ihre Datei jedoch bereits vorhanden ist, müssen Sie dies nicht angeben, da der Standardwert lautet FALSE.

Hier einige Screenshots der erstellten Arbeitsmappe:

Geben Sie hier die Bildbeschreibung ein

Geben Sie hier die Bildbeschreibung ein

Geben Sie hier die Bildbeschreibung ein

nrussell
quelle
1
Ich habe XLConnect nicht verwendet, sehr detailliertes Beispiel, danke!
Ogre Magi
Gern geschehen - ich habe festgestellt, dass es ein sehr nützliches Paket ist. Es gibt eine ziemlich gute Vignette auf CRAN , die einige der Hauptfunktionen detailliert beschreibt. Ein schönes Beispiel in Abschnitt 4 zeigt, wie R-Diagramme in ein Arbeitsblatt geschrieben werden.
Nrussell
5

Wenn die Datengröße klein ist, verfügt R über viele Pakete und Funktionen, die gemäß Ihren Anforderungen verwendet werden können.

write.xlsx, write.xlsx2, XLconnect erledigen ebenfalls die Arbeit, aber diese sind im Vergleich zu openxlsx manchmal langsam .

Also, wenn Sie mit den großen Datenmengen zu tun haben und auf Java-Fehler gestoßen sind. Ich würde vorschlagen, einen Blick auf "openxlsx" zu werfen was wirklich großartig ist und die Zeit auf reduziert.

Ich habe alle getestet und war schließlich sehr beeindruckt von der Leistung der openxlsx-Funktionen.

Hier sind die Schritte zum Schreiben mehrerer Datensätze in mehrere Blätter.

 install.packages("openxlsx")
 library("openxlsx")

    start.time <- Sys.time()

    # Creating large data frame
    x <- as.data.frame(matrix(1:4000000,200000,20))
    y <- as.data.frame(matrix(1:4000000,200000,20))
    z <- as.data.frame(matrix(1:4000000,200000,20))

    # Creating a workbook
    wb <- createWorkbook("Example.xlsx")
    Sys.setenv("R_ZIPCMD" = "C:/Rtools/bin/zip.exe") ## path to zip.exe

Sys.setenv ("R_ZIPCMD" = "C: /Rtools/bin/zip.exe") muss statisch sein, da es auf ein Dienstprogramm von Rtools verweist.

Hinweis: Wenn Rtools nicht auf Ihrem System installiert ist, installieren Sie es bitte zuerst, um einen reibungslosen Ablauf zu gewährleisten. Hier ist der Link für Ihre Referenz: (Wählen Sie die entsprechende Version)

https://cran.r-project.org/bin/windows/Rtools/ Aktivieren Sie die Optionen gemäß dem folgenden Link (aktivieren Sie während der Installation alle Kontrollkästchen).

https://cloud.githubusercontent.com/assets/7400673/12230758/99fb2202-b8a6-11e5-82e6-836159440831.png

    # Adding a worksheets : parameters for addWorksheet are 1. Workbook Name 2. Sheet Name

    addWorksheet(wb, "Sheet 1")
    addWorksheet(wb, "Sheet 2")
    addWorksheet(wb, "Sheet 3")

    # Writing data in to respetive sheets: parameters for writeData are 1. Workbook Name 2. Sheet index/ sheet name 3. dataframe name

    writeData(wb, 1, x)

    # incase you would like to write sheet with filter available for ease of access you can pass the parameter withFilter = TRUE in writeData function.
    writeData(wb, 2, x = y, withFilter = TRUE)

    ## Similarly writeDataTable is another way for representing your data with table formatting:

    writeDataTable(wb, 3, z)

    saveWorkbook(wb, file = "Example.xlsx", overwrite = TRUE)

    end.time <- Sys.time()
    time.taken <- end.time - start.time
    time.taken

openxlsx Paket eignet sich zum Lesen und Schreiben großer Datenmengen aus / in Excel-Dateien und bietet zahlreiche Optionen für die benutzerdefinierte Formatierung in Excel.

Die interessante Tatsache ist, dass wir uns hier nicht um Java-Heap-Speicher kümmern müssen.

Ayush Varshney
quelle
3

Ich hatte genau dieses Problem und habe es folgendermaßen gelöst:

library(openxlsx) # loads library and doesn't require Java installed

your_df_list <- c("df1", "df2", ..., "dfn")

for(name in your_df_list){
  write.xlsx(x = get(name), 
             file = "your_spreadsheet_name.xlsx", 
             sheetName = name)
}

Auf diese Weise müssen Sie keine sehr lange Liste manuell erstellen, wenn Sie Tonnen von Datenrahmen zum Schreiben in Excel haben.

Alexmathios
quelle
2
Ich weiß nicht, warum dies das erste Arbeitsblatt überschreibt
Lunalo John
1

Ich benutze das verpackte Rio regelmäßig für den Export aller Art. Mit rio können Sie eine Liste eingeben, jede Registerkarte benennen und den Datensatz angeben. rio kompiliert andere In / Out-Pakete und verwendet für den Export nach Excel openxlsx.

library(rio)

filename <- "C:/R_code/../file.xlsx"

export(list(sn1 = tempTable1, sn2 = tempTable2, sn3 = tempTable3), filename)
24indsey
quelle
0

Für mich, WriteXLSBietet die Funktionalität, die Sie suchen. Da Sie nicht angegeben haben, welche Fehler zurückgegeben werden, zeige ich Ihnen ein Beispiel:

Beispiel

library(WriteXLS)
x <- list(sheet_a = data.frame(a=letters), sheet_b = data.frame(b = LETTERS))
WriteXLS(x, "test.xlsx", names(x))

Erläuterung

Wenn xist:

  • Eine Liste von Datenrahmen, von denen jeder auf ein einzelnes Blatt geschrieben ist
  • Als Zeichenvektor (von R Objekten) wird jedes Objekt auf ein einzelnes Blatt geschrieben
  • etwas anderes, dann sehen Sie auch, was die Hilfe sagt:

Mehr zur Verwendung

?WriteXLS

zeigt an:

`x`: A character vector or factor containing the names of one or
     more R data frames; A character vector or factor containing
     the name of a single list which contains one or more R data
     frames; a single list object of one or more data frames; a
     single data frame object.

Lösung

In Ihrem Beispiel müssten Sie während der Schleife alle data.frames in einer Liste sammeln und WriteXLSnach Beendigung der Schleife verwenden.

Sitzungsinfo

  • R 3.2.4
  • WriteXLS 4.0.0
setempler
quelle
Dieses Paket wird funktionieren, aber meiner Meinung nach würde ich versuchen, die Abhängigkeit von Perl zu vermeiden (wie ich versuchen würde, die Abhängigkeit von Java mit zu vermeiden xlsx), da es schwieriger einzurichten ist
R Yoda
0

Ich mache es auf diese Weise für openxlsx mit der folgenden Funktion

mywritexlsx<-function(fname="temp.xlsx",sheetname="Sheet1",data,
                  startCol = 1, startRow = 1, colNames = TRUE, rowNames = FALSE)
{
  if(! file.exists(fname))
    wb = createWorkbook()
  else
   wb <- loadWorkbook(file =fname)
  sheet = addWorksheet(wb, sheetname)

  writeData(wb,sheet,data,startCol = startCol, startRow = startRow, 
          colNames = colNames, rowNames = rowNames)
  saveWorkbook(wb, fname,overwrite = TRUE)
}
Makarand Kulkarni
quelle
loadWorkbook ist hier der Schlüssel zum Öffnen vorhandener Dateien
makarand kulkarni
Auch wenn man Formeln schreiben möchte, um Excel zu erstellen, gibt es eine andere Funktion namens writeFormula. Außerdem muss die Datei nach dem Schreiben der Formel aktualisiert oder erneut geöffnet, dann gespeichert und dann in Excel geschlossen werden. Demo wird hier gegeben [Link ( stackoverflow.com/questions/46914303/… )
Makarand Kulkarni
0

Ich mache das die ganze Zeit, alles was ich mache ist

WriteXLS::WriteXLS(
    all.dataframes,
    ExcelFileName = xl.filename,
    AdjWidth = T,
    AutoFilter = T,
    FreezeRow = 1,
    FreezeCol = 2,
    BoldHeaderRow = T,
    verbose = F,
    na = '0'
  )

und all diese Datenrahmen kommen von hier

all.dataframes <- vector()
for (obj.iter in all.objects) {
  obj.name <- obj.iter
  obj.iter <- get(obj.iter)
  if (class(obj.iter) == 'data.frame') {
      all.dataframes <- c(all.dataframes, obj.name)
}

Offensichtlich wäre sapply Routine hier besser

Suman C.
quelle
0

für eine lapply-freundliche Version ..

library(data.table)
library(xlsx)

path2txtlist <- your.list.of.txt.files
wb <- createWorkbook()
lapply(seq_along(path2txtlist), function (j) {
sheet <- createSheet(wb, paste("sheetname", j))
addDataFrame(fread(path2txtlist[j]), sheet=sheet, startColumn=1, row.names=FALSE)
})

saveWorkbook(wb, "My_File.xlsx")
MinimaMoralia
quelle
1
Könnten Sie dieser Antwort eine Beschreibung hinzufügen, um einen Kontext für die Beantwortung der Frage bereitzustellen?
Tshimkus