R: einfache Möglichkeit, mehrere data.frame in mehrere Excel-Arbeitsblätter zu exportieren?

Sie können die openxlsx-Bibliothek auch verwenden, um mehrere Datasets in mehrere Arbeitsblä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, wobei 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")

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 (mit der Dev-Version arbeiten):

library(writexl)
sheets <- list("sheet1Name" = sheet1, "sheet2Name" = sheet2) #assume sheet1 and sheet2 are data frames
write_xlsx(sheets, "path/to/location")

Viele gute Antworten hier, aber einige davon sind schon etwas älter. Wenn Sie weitere Arbeitsblätter zu einer einzelnen Datei hinzufügen möchten, ist dies der Ansatz, den ich für mich als funktionierend finde. Zur Verdeutlichung ist hier der Workflow für openxlsx Version 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 @ Syeds mag ich wirklich sehr. Es nutzt nicht alle Funktionen von openxlsx, aber wenn Sie eine schnelle und einfache Exportmethode wünschen, ist dies wahrscheinlich die einfachste.

Ich bin nicht vertraut mit dem Paket WriteXLS; Ich benutze generell 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 @joran oben erwähnt hat, aber um dynamische Blattnamen schnell zu erzeugen, habe ich zur Demonstration eine for-Schleife verwendet.

Ich habe das create=TRUE-Argument in loadWorkbook verwendet, seit ich eine neue .xlsx-Datei erstellt habe. Wenn Ihre Datei jedoch bereits vorhanden ist, müssen Sie dies nicht angeben, da der Standardwert FALSE ist.

Hier sind ein paar Screenshots der erstellten Arbeitsmappe:

Wenn die Datengröße klein ist, verfügt R über viele Pakete und Funktionen, die je nach Anforderung verwendet werden können.

write.xlsx, write.xlsx2, XLconnect erledigen auch die Arbeit, diese sind jedoch manchmal slow als Vergleich mit openxlsx. 

Wenn Sie sich also mit den großen Datenmengen beschäftigen 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 1/12 reduzieren.

Ich habe alles getestet und endlich war ich wirklich beeindruckt von der Leistungsfähigkeit der openxlsx-Fähigkeiten.

Hier sind die Schritte zum Schreiben mehrerer Datensätze in mehrere Arbeitsblä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 sich auf ein Hilfsprogramm von Rtools bezieht.

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

https://cran.r-project.org/bin/windows/Rtools/ Überprüfen Sie die Optionen wie unten stehend (müssen Sie während der Installation alle Kontrollkästchen aktivieren)

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

Das Paket openxlsx eignet sich hervorragend zum Lesen und Schreiben riesiger Daten 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.

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.

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 alle 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 hier eine angenehme Routine besser

Für mich stellt WriteXLS die Funktionalität bereit, nach der 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))

Erklärung

Wenn x ist: 

• eine Liste von Datenrahmen, die jeweils auf ein Blatt geschrieben werden
• ein Zeichenvektor (von R-Objekten), jedes Objekt wird in ein einzelnes Blatt geschrieben
• etwas anderes, dann sehen Sie auch, was die Hilfe besagt:

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 nach Abschluss der Schleife WriteXLS verwenden.

Sitzungsinfo

• R 3.2.4
• WriteXLS 4.0.0

Ich mache es auf diese Weise für openxlsx mit folgender 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)
}

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