una txt studio resultados matriz guardar exportar datos data r excel xlsx

txt - exportar una matriz de r a excel



Manera fácil de exportar múltiples data.frame a múltiples hojas de cálculo de Excel (11)

Me sorprende descubrir que no hay una manera fácil de exportar múltiples data.frame a múltiples hojas de trabajo de un archivo Excel. Probé el paquete xlsx , parece que solo puede escribir en una hoja (anular la hoja anterior); También probé el paquete WriteXLS , pero me da errores todo el tiempo ...

La estructura de mi código es así: por diseño, para cada iteración, el marco de datos de salida (tempTable) y sheetName (sn) se actualizaron y exportaron a una sola pestaña.

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

Puedo exportar a varios archivos cvs, pero tiene que haber una manera fácil de hacerlo en Excel, ¿verdad?

En caso de que el tamaño de los datos sea pequeño, R tiene muchos paquetes y funciones que se pueden utilizar según sus necesidades.

write.xlsx, write.xlsx2, XLconnect también hacen el trabajo, pero a veces son lentos en comparación con openxlsx .

Entonces, si está tratando con grandes conjuntos de datos y se encontró con errores de Java. Sugeriría tener un aspecto de "openxlsx", que es realmente impresionante y reduce el tiempo a 1/12 .

Lo probé todo y, finalmente, quedé realmente impresionado con el rendimiento de las capacidades de openxlsx.

Estos son los pasos para escribir múltiples conjuntos de datos en varias hojas.

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") tiene que ser estático ya que toma referencia de alguna utilidad de Rtools.

Nota: Incase Rtools no está instalado en su sistema, instálelo primero para obtener una experiencia fluida. Aquí está el enlace para su referencia: (elija la versión adecuada)

https://cran.r-project.org/bin/windows/Rtools/ verifique las opciones según el enlace a continuación (debe seleccionar todas las casillas de verificación durante la instalación)

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

El paquete openxlsx es realmente bueno para leer y escribir grandes datos de / en archivos de Excel y tiene muchas opciones para el formato personalizado dentro de Excel.

El hecho interesante es que no tenemos que preocuparnos por la memoria de almacenamiento dinámico de Java aquí.

Hago esto todo el tiempo, todo lo que hago es

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

y todos esos marcos de datos provienen de aquí

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

obviamente, la rutina de aplicación sería mejor aquí

Hay una nueva biblioteca en la ciudad, de rOpenSci: writexl

Marco de datos portátil y liviano para exportador xlsx basado en libxlsxwriter. No requiere Java ni Excel

Lo encontré mejor y más rápido que las sugerencias anteriores (trabajando con la versión de desarrollo):

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

Lo hago de esta manera para openxlsx usando la siguiente función

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

Muchas buenas respuestas aquí, pero algunas están un poco anticuadas. Si desea agregar más hojas de trabajo a un solo archivo, este es el enfoque que creo que funciona para mí. Para mayor claridad, aquí está el flujo de trabajo para openxlsx versión 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")

EDITAR

Ahora he probado algunas otras respuestas, y en realidad me gusta mucho @ Syed. No explota toda la funcionalidad de openxlsx pero si desea un método de exportación rápido y fácil, entonces probablemente sea el más sencillo.

No estoy familiarizado con el paquete WriteXLS ; Generalmente uso 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)

Ciertamente, esto se puede vectorizar, como señaló @joran anteriormente, pero solo por generar nombres de hoja dinámicos rápidamente, utilicé un bucle for para demostrarlo.

loadWorkbook argumento create=TRUE en loadWorkbook ya que estaba creando un nuevo archivo .xlsx, pero si su archivo ya existe, entonces no tiene que especificar esto, ya que el valor predeterminado es FALSE .

Aquí hay algunas capturas de pantalla del libro de trabajo creado:

Para mí, WriteXLS proporciona la funcionalidad que está buscando. Como no especificó qué errores devuelve, le muestro un ejemplo:

Ejemplo

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

Explicación

Si x es:

  • una lista de marcos de datos, cada uno está escrito en una sola hoja
  • un vector de caracteres (de objetos R), cada objeto se escribe en una sola hoja
  • algo más, luego vea también lo que dice la ayuda:

Más sobre el uso

?WriteXLS

muestra:

`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.

Solución

Para su ejemplo, necesitaría recopilar todos los data.frames en una lista durante el ciclo y usar WriteXLS después de que el ciclo haya finalizado.

Información de la sesión

  • R 3.2.4
  • WriteXLS 4.0.0

Puede escribir en varias hojas con el paquete xlsx . Solo necesita usar un sheetName diferente para cada marco de datos y debe agregar 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)

Otra opción, una que le brinda más control sobre el formateo y la ubicación del marco de datos, es hacer todo dentro del código R / xlsx y luego guardar el libro al final. Por ejemplo:

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

En caso de que le resulte útil, aquí hay algunas funciones auxiliares interesantes que hacen que sea más fácil agregar formato, metadatos y otras características a las hojas de cálculo usando xlsx : http://www.sthda.com/english/wiki/r2excel-read-write-and-format-easily-excel-files-using-r-software

También puede usar la biblioteca openxlsx para exportar múltiples conjuntos de datos a varias hojas en un solo libro de trabajo. La ventaja de openxlsx sobre xlsx es que openxlsx elimina las dependencias de las bibliotecas de Java.

Escriba una lista de data.frames en hojas de trabajo individuales usando nombres de listas como nombres de hojas de trabajo.

require(openxlsx) list_of_datasets <- list("Name of DataSheet1" = dataframe1, "Name of Datasheet2" = dataframe2) write.xlsx(list_of_datasets, file = "writeXLSX2.xlsx")

Tuve este problema exacto y lo resolví de esta manera:

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

De esa manera, no tendrá que crear una lista muy larga manualmente si tiene toneladas de marcos de datos para escribir en Excel.

para una versión amigable para lapply ..

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