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

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?

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

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

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

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.

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:

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.

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

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

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

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

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