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