Zaskoczyło mnie, że nie ma łatwego sposobu na wyeksportowanie wielu data.frame do wielu arkuszy w pliku Excel? Wypróbowałem pakiet xlsx , wydaje się, że można pisać tylko na jednym arkuszu (nadpisać stary arkusz); Próbowałem też paczki WriteXLS , ale cały czas daje mi błąd ...
Moja struktura kodu jest następująca: zgodnie z projektem, dla każdej iteracji wyjściowa ramka danych (tempTable) i SheetName (sn) zostały zaktualizowane i wyeksportowane do jednej karty.
for (i in 2 : ncol(code)){
...
tempTable <- ...
sn <- ...
WriteXLS("tempTable", ExcelFileName = "C:/R_code/../file.xlsx",
SheetNames = sn);
}
Mogę eksportować do kilku plików cvs, ale musi być na to łatwy sposób w Excelu, prawda?
createSheet
funkcja, która pozwala tworzyć nowe arkusze, a następnie pisać do nich w pętli. Dodatkowo równoważne funkcje w XLConnect są wektoryzowane, co pozwala na zapisywanie listy ramek danych na wielu arkuszach.Odpowiedzi:
Możesz pisać na wielu arkuszach z
xlsx
paczką. Wystarczy użyć innejsheetName
ramki dla każdej ramki danych i dodać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)
Inną opcją, która zapewnia większą kontrolę nad formatowaniem i miejscem umieszczenia ramki danych, jest zrobienie wszystkiego w kodzie R / xlsx, a następnie zapisanie skoroszytu na końcu. Na przykład:
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")
Jeśli uznasz to za przydatne, oto kilka interesujących funkcji pomocniczych, które ułatwiają dodawanie formatowania, metadanych i innych funkcji do arkuszy kalkulacyjnych za pomocą
xlsx
: http://www.sthda.com/english/wiki/r2excel-read-write -i-format-łatwo-pliki-excel-używając-oprogramowania-rźródło
xlsx
nie dba o liczby w pierwszym rzędzie R umieszczając tam.openxlsx
Usuń ich.row.names=FALSE
aby usunąć nazwy wierszy.xlsx
naopenxlsx
jakiś czas temu, ponieważ uważam, że jest znacznie bardziej intuicyjny, a także unika zależności od Java.openxlsx
zapoznać się z metodą z wersją 4.0, zobacz moją dodatkową odpowiedź poniżej.Możesz również użyć biblioteki openxlsx do wyeksportowania wielu zestawów danych do wielu arkuszy w jednym skoroszycie. Przewaga openxlsx nad xlsx polega na tym, że openxlsx usuwa zależności od bibliotek java.
Napisz listę data.frames do poszczególnych arkuszy, używając nazw list jako nazw arkuszy.
require(openxlsx) list_of_datasets <- list("Name of DataSheet1" = dataframe1, "Name of Datasheet2" = dataframe2) write.xlsx(list_of_datasets, file = "writeXLSX2.xlsx")
źródło
openxlsx
jest najszybszy, ponieważ jego c ++.XlConnect
zje twój RAM. Może zechcesz zrobić kilka testów porównawczych międzyxlsx
aopenxlsx
openxlsx::write.xlsx
to droga do zrobienia ... Zapisałem 11 arkuszy, każdy w ramce danych 20000x10, gotowe to kilka sekund, podczas gdy błądxlsx::write.xlsx
po dołączeniu drugiego arkusza zjava.lang.OutOfMemoryError: Java heap space
append=TRUE
do write.xlsx, aby zapisywał kilka arkuszy naraz do jednego pliku Excelalist_of_dfs <- list()
), a następnie wypełnić, używając temp_key i temp_df skonstruowanych podczas pętli (list_of_dfs[[temp_key]] = temp_df
). Pisanie było również bardzo szybkie, pomimo 16 arkuszy, które musiałem stworzyć! Czy ktoś był świadkiem problemów z pamięcią podczas tworzenia?W mieście jest nowa biblioteka od rOpenSci: writexl
Znalazłem to lepiej i szybciej niż powyższe sugestie (praca z wersją dev):
library(writexl) sheets <- list("sheet1Name" = sheet1, "sheet2Name" = sheet2) #assume sheet1 and sheet2 are data frames write_xlsx(sheets, "path/to/location")
źródło
Wiele dobrych odpowiedzi tutaj, ale niektóre z nich są trochę przestarzałe. Jeśli chcesz dodać kolejne arkusze do jednego pliku, to jest to podejście, które uważam za skuteczne. Dla jasności, oto przepływ pracy dla
openxlsx
wersji 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")
EDYTOWAĆ
Wypróbowałem teraz kilka innych odpowiedzi i naprawdę lubię @ Syed's. Nie wykorzystuje wszystkich funkcji programu,
openxlsx
ale jeśli chcesz mieć szybką i łatwą metodę eksportu, jest to prawdopodobnie najprostsza metoda.źródło
Nie znam pakietu
WriteXLS
; Generalnie używamXLConnect
: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)
Można to z pewnością wektoryzować, jak zauważył @joran powyżej, ale tylko w celu szybkiego generowania dynamicznych nazw arkuszy użyłem
for
pętli do zademonstrowania.Użyłem
create=TRUE
argumentu w,loadWorkbook
ponieważ tworzyłem nowy plik .xlsx, ale jeśli twój plik już istnieje, nie musisz tego określać, ponieważ wartość domyślna toFALSE
.Oto kilka zrzutów ekranu utworzonego skoroszytu:
źródło
Rozmiar danych Incase jest niewielki, R ma wiele pakietów i funkcji, które można wykorzystać zgodnie z wymaganiami.
write.xlsx, write.xlsx2, XLconnect również działają, ale czasami są one powolne w porównaniu do openxlsx .
Tak więc, jeśli masz do czynienia z dużymi zestawami danych i napotkałeś błędy Java. Proponuję spojrzeć na „openxlsx”, co jest naprawdę niesamowite i skrócić czas do 1/12.
Przetestowałem wszystko i ostatecznie byłem pod wielkim wrażeniem wydajności możliwości openxlsx.
Oto kroki, aby zapisać wiele zestawów danych w wielu arkuszach.
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") musi być statyczny, ponieważ pobiera odniesienie do jakiegoś narzędzia z Rtools.
Uwaga: narzędzie Incase Rtools nie jest zainstalowane w twoim systemie, zainstaluj go najpierw, aby uzyskać płynne działanie. tutaj jest link do twojego odniesienia: (wybierz odpowiednią wersję)
https://cran.r-project.org/bin/windows/Rtools/ sprawdź opcje zgodnie z poniższym linkiem (podczas instalacji należy zaznaczyć wszystkie pola wyboru)
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
openxlsxPakiet jest naprawdę dobry do czytania i zapisywania ogromnych danych z / w plikach Excela i ma wiele opcji niestandardowego formatowania w programie Excel.
Ciekawostką jest to, że nie musimy się tutaj przejmować pamięcią stosu Java.
źródło
Miałem dokładnie ten problem i rozwiązałem go w ten sposób:
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) }
W ten sposób nie będziesz musiał ręcznie tworzyć bardzo długiej listy, jeśli masz mnóstwo ramek danych do zapisania w programie Excel.
źródło
Regularnie używam zapakowanego rio do eksportu wszelkiego rodzaju. Używając rio, możesz wprowadzić listę, nazwać każdą kartę i określić zestaw danych. rio kompiluje inne pakiety wejścia / wyjścia, a do eksportu do Excela używa openxlsx.
library(rio) filename <- "C:/R_code/../file.xlsx" export(list(sn1 = tempTable1, sn2 = tempTable2, sn3 = tempTable3), filename)
źródło
Dla mnie
WriteXLS
zapewnia funkcjonalność, której szukasz. Ponieważ nie określiłeś, które błędy zwraca, pokażę ci przykład:Przykład
library(WriteXLS) x <- list(sheet_a = data.frame(a=letters), sheet_b = data.frame(b = LETTERS)) WriteXLS(x, "test.xlsx", names(x))
Wyjaśnienie
Jeśli
x
jest:Więcej o użytkowaniu
przedstawia:
Rozwiązanie
Na przykład musisz zebrać wszystkie data.frames na liście podczas pętli i użyć ich
WriteXLS
po zakończeniu pętli.Informacje o sesji
źródło
xlsx
), ponieważ utrudnia to konfiguracjęRobię to w ten sposób dla openxlsx używając następującej funkcji
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) }
źródło
Robię to cały czas, jedyne co robię to
WriteXLS::WriteXLS( all.dataframes, ExcelFileName = xl.filename, AdjWidth = T, AutoFilter = T, FreezeRow = 1, FreezeCol = 2, BoldHeaderRow = T, verbose = F, na = '0' )
i wszystkie te ramki danych pochodzą stąd
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) }
oczywiście rozsądna rutyna byłaby tutaj lepsza
źródło
dla wersji przyjaznej dla aplikacji.
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")
źródło