R: moyen facile d’exporter plusieurs données.fr vers plusieurs feuilles de calcul Excel?
Je suis surpris de constater qu’il n’existe pas de moyen simple d’exporter plusieurs data.frame vers plusieurs feuilles de calcul d’un fichier Excel. J'ai essayé le paquet xlsx, il semble qu'il ne peut écrire que sur une seule feuille (remplacer l'ancienne feuille); J'ai aussi essayé le paquet WriteXLS, mais ça me donne une erreur tout le temps ...
Ma structure de code est la suivante: par conception, pour chaque itération, la structure de données en sortie (tempTable) et le nom de feuille (snom) ont été mis à jour et exportés dans un seul onglet.
for (i in 2 : ncol(code)){
...
tempTable <- ...
sn <- ...
WriteXLS("tempTable", ExcelFileName = "C:/R_code/../file.xlsx",
SheetNames = sn);
}
Je peux exporter vers plusieurs fichiers CVS, mais il doit exister un moyen simple de le faire dans Excel, non?
Merci d'avance.
Vous pouvez écrire sur plusieurs feuilles avec le package xlsx. Vous devez simplement utiliser une variable sheetName différente pour chaque trame de données et vous devez ajouter 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)
Une autre option, qui vous donne davantage de contrôle sur le formatage et l'emplacement du bloc de données, consiste à tout faire dans le code R/xlsx, puis à enregistrer le classeur à la fin. Par exemple:
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")
Au cas où cela vous serait utile, voici quelques fonctions d'assistance intéressantes qui facilitent l'ajout de la mise en forme, des métadonnées et d'autres fonctionnalités aux feuilles de calcul à l'aide de xlsx: http://www.sthda.com/english/wiki/r2Excel-lecture-écriture-et-formatage-facile-fichiers-Excel-utilisant-logiciel-r
Vous pouvez également utiliser la bibliothèque openxlsx pour exporter plusieurs jeux de données vers plusieurs feuilles d'un même classeur. L'avantage d'openxlsx par rapport à xlsx est que openxlsx supprime les dépendances des bibliothèques Java.
Rédigez une liste de data.frames dans des feuilles de calcul individuelles en utilisant des noms de liste comme noms de feuille de calcul.
require(openxlsx)
list_of_datasets <- list("Name of DataSheet1" = dataframe1, "Name of Datasheet2" = dataframe2)
write.xlsx(list_of_datasets, file = "writeXLSX2.xlsx")
Il y a une nouvelle bibliothèque en ville, de rOpenSci: writexl
Trame de données portable et légère pour l'exportateur xlsx basée sur libxlsxwriter. Aucun Java ou Excel requis
Je l'ai trouvé meilleur et plus rapide que les suggestions ci-dessus (travailler avec la version dev):
library(writexl)
sheets <- list("sheet1Name" = sheet1, "sheet2Name" = sheet2) #assume sheet1 and sheet2 are data frames
write_xlsx(sheets, "path/to/location")
Beaucoup de bonnes réponses ici, mais certaines sont un peu datées. Si vous souhaitez ajouter d'autres feuilles de calcul à un seul fichier, c'est l'approche que je trouve qui fonctionne pour moi. Pour plus de clarté, voici le workflow pour 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")
MODIFIER
J'ai maintenant testé quelques autres réponses, et j'aime vraiment beaucoup @ Syed's. Il n'exploite pas toutes les fonctionnalités de openxlsx, mais si vous voulez une méthode d'exportation rapide et facile, c'est probablement la plus simple.
Je ne connais pas le paquet WriteXLS; J'utilise généralement 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)
Ceci peut certainement être vectorisé, comme @joran l’a noté plus haut, mais dans le seul but de générer rapidement des noms de feuille dynamiques, j’ai utilisé une boucle for pour la démontrer.
J'ai utilisé l'argument create=TRUE dans loadWorkbook puisque je créais un nouveau fichier .xlsx, mais si votre fichier existe déjà, vous n'avez pas à le spécifier, car la valeur par défaut est FALSE.
Voici quelques captures d'écran du classeur créé:
La taille des données en cas est petite, R propose de nombreux packages et fonctions pouvant être utilisées selon vos besoins.
write.xlsx, write.xlsx2, XLconnect effectuent également le travail, mais il s’agit parfois de slow, contrairement à openxlsx.
Donc, si vous traitez avec des ensembles de données volumineux et rencontrez des erreurs Java. Je suggérerais de regarder "openxlsx" qui est vraiment génial et de réduire le temps à 1/12ème.
J'ai tout testé et finalement, j'ai été vraiment impressionné par les performances des fonctionnalités openxlsx.
Voici les étapes à suivre pour écrire plusieurs jeux de données dans plusieurs feuilles.
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") doit être statique car il prend en référence un utilitaire de Rtools.
Remarque: Incase Rtools n’est pas installé sur votre système, installez-le d'abord pour une expérience optimale. voici le lien pour votre référence: (choisissez la version appropriée)
https://cran.r-project.org/bin/windows/Rtools/ Cochez les options selon le lien ci-dessous (vous devez cocher toutes les cases lors de l'installation)
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
Le paquetage openxlsx est vraiment bon pour la lecture et l’écriture de données volumineuses à partir de/dans des fichiers Excel et offre de nombreuses options pour la mise en forme personnalisée dans Excel.
Le fait intéressant est que nous n’avons pas à nous préoccuper de la mémoire heap Java.
Je fais ça tout le temps, tout ce que je fais est
WriteXLS::WriteXLS(
all.dataframes,
ExcelFileName = xl.filename,
AdjWidth = T,
AutoFilter = T,
FreezeRow = 1,
FreezeCol = 2,
BoldHeaderRow = T,
verbose = F,
na = '0'
)
et toutes ces trames de données viennent d'ici
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)
}
évidemment sapply routine serait mieux ici
Pour moi, WriteXLS fournit la fonctionnalité que vous recherchez. Puisque vous n'avez pas spécifié les erreurs qu'il renvoie, je vous montre un exemple:
Exemple
library(WriteXLS)
x <- list(sheet_a = data.frame(a=letters), sheet_b = data.frame(b = LETTERS))
WriteXLS(x, "test.xlsx", names(x))
Explication
Si x est:
- une liste de trames de données, chacune étant écrite sur une seule feuille
- un vecteur de caractère (d'objets R), chaque objet est écrit sur une seule feuille
- autre chose, puis voyez aussi ce que dit l’aide:
Plus sur l'utilisation
?WriteXLS
spectacles:
`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.
Solution
Pour votre exemple, vous devez collecter tous les data.frames dans une liste pendant la boucle et utiliser WriteXLS à la fin de la boucle.
Informations sur la session
- R 3.2.4
- WriteXLS 4.0.0
Je le fais de cette manière pour openxlsx en utilisant la fonction suivante
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)
}
pour une version lapply-friendly ..
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")