0Pricing
R Academy · Lezione

Scrittura dei dati in più formati

Esporti data frame in CSV, Excel e RDS con write_csv() e writexl.

Scrittura dei dati in più formati è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Scrittura di dati da R

La lettura dei dati è solo metà del lavoro: è necessario anche salvare i risultati. R supporta diversi formati di output: CSV per la compatibilità universale, RDS per preservare esattamente gli oggetti R, Parquet per analisi ad alte prestazioni e altri ancora. Scelga il formato in base al pubblico destinatario e al caso d'uso.

library(readr)

# Create a sample data frame to write
df <- data.frame(
  name = c('Alice','Bob','Carol'),
  score = c(85.5, 92.0, 78.3),
  grade = c('B','A','C'),
  passed = c(TRUE, TRUE, TRUE)
)

print(df)
cat('\nWe will save this in multiple formats!')

write_csv() — Salvataggio in formato CSV

write_csv(df, 'file.csv') salva un data frame come file separato da virgole. Per impostazione predefinita non scrive i nomi delle righe (a differenza di write.csv()). Il risultato è sempre codificato in UTF-8. Restituisce il data frame in modo invisibile, quindi può essere utilizzato nelle pipe.

library(readr)

df <- data.frame(
  name = c('Alice','Bob','Carol'),
  score = c(85, 92, 78)
)

# Write to /tmp for demonstration
write_csv(df, '/tmp/students.csv')

# Verify by reading back
read_csv('/tmp/students.csv', show_col_types=FALSE)

Opzioni di write_csv()

write_csv() accetta diverse opzioni: na='NA' controlla come vengono scritti i valori NA, append=TRUE aggiunge dati a un file esistente, col_names=FALSE omette l'intestazione e quote controlla quando racchiudere i campi tra virgolette.

library(readr)

df <- data.frame(
  name = c('Alice','Bob'),
  city = c('New York','Los,Angeles'),  # Contains comma
  score = c(85, NA)
)

# na='' writes NA as empty string (common Excel convention)
write_csv(df, '/tmp/test_write.csv', na='')
cat(paste(read_lines('/tmp/test_write.csv'), collapse='\n'))

write_tsv() — Output separato da tabulazioni

write_tsv(df, 'file.tsv') salva i dati separandoli con tabulazioni. È preferibile quando i dati contengono virgole o quando il sistema a valle richiede il formato TSV. Le opzioni sono le stesse di write_csv().

library(readr)

df <- data.frame(
  address = c('123 Main St, NYC','456 Oak Ave, LA'),
  score = c(85, 92)
)

# TSV avoids delimiter conflict with commas in addresses
write_tsv(df, '/tmp/addresses.tsv')
cat(paste(read_lines('/tmp/addresses.tsv'), collapse='\n'))

saveRDS() — Salvataggio di qualsiasi oggetto R

saveRDS(obj, 'file.rds') serializza qualsiasi oggetto R su disco nel formato binario nativo di R. readRDS('file.rds') lo ripristina esattamente, preservando i tipi delle colonne, i factor, gli attributi e persino gli oggetti modello. Non è leggibile dall'uomo, ma è perfettamente portabile tra sessioni R.

library(readr)

df <- data.frame(
  name = c('Alice','Bob'),
  score = c(85.5, 92.0),
  grade = factor(c('B','A'), levels=c('A','B','C','D'))
)

# Save with full type preservation
saveRDS(df, '/tmp/students.rds')

# Restore exactly
df2 <- readRDS('/tmp/students.rds')
print(df2)
print(class(df2$grade))  # factor — preserved!

saveRDS() e save() — Differenza principale

saveRDS(obj, 'file.rds') salva un singolo oggetto senza il relativo nome. readRDS() consente di assegnargli qualsiasi nome. save(obj1, obj2, 'file.RData') salva più oggetti con nome; load() li ripristina con i nomi originali (e può sovrascrivere variabili esistenti).

# saveRDS: single object, flexible on load
model <- lm(mpg ~ wt, data=mtcars)
saveRDS(model, '/tmp/my_model.rds')
best_model <- readRDS('/tmp/my_model.rds')  # Any name!
cat('R-squared:', round(summary(best_model)$r.squared, 3), '\n')

# save: multiple named objects, fixed names on load
# save(model, mtcars, file='/tmp/workspace.RData')
# load('/tmp/workspace.RData')  # Restores 'model' and 'mtcars'

write_delim() — Delimitatore personalizzato

write_delim(df, file, delim='|') scrive i dati utilizzando qualsiasi delimitatore. Lo utilizzi quando il sistema a valle richiede un formato delimitato da barre verticali o un altro formato non standard. Si applicano le stesse garanzie sulla qualità dei dati di write_csv().

library(readr)

df <- data.frame(
  id = 1:3,
  name = c('Alice','Bob','Carol'),
  value = c(100, 200, 150)
)

# Write pipe-delimited
write_delim(df, '/tmp/data.psv', delim='|')
cat(paste(read_lines('/tmp/data.psv'), collapse='\n'))

Output Excel con writexl

Il pacchetto writexl (complementare di readxl) scrive i data frame nel formato .xlsx: writexl::write_xlsx(df, 'file.xlsx'). Per più fogli, passi una lista con nome. Non sono necessarie né Java né un'installazione di Excel.

# writexl::write_xlsx() — example (library not always available)
# library(writexl)

df1 <- data.frame(name=c('Alice','Bob'), score=c(85,92))
df2 <- data.frame(region=c('East','West'), sales=c(100,200))

# Single sheet:
# write_xlsx(df1, '/tmp/students.xlsx')

# Multiple sheets (named list):
# write_xlsx(
#   list(students=df1, sales=df2),
#   '/tmp/report.xlsx'
# )

cat('writexl writes pure .xlsx without Java or Excel!')

File Parquet con arrow

Apache Parquet è un formato di archiviazione colonnare ideale per grandi dataset: offre una buona compressione e legge i dati molto più velocemente del CSV per le query orientate alle colonne. Il pacchetto arrow fornisce write_parquet() e read_parquet().

# arrow::write_parquet() concept
# library(arrow)

# Large CSV -> Parquet (10-100x smaller, 10-100x faster reads)
# df <- read_csv('big_file.csv')
# write_parquet(df, 'big_file.parquet')
# df_back <- read_parquet('big_file.parquet')

# Parquet benefits:
# - Columnar: only reads columns you need
# - Compressed: ~10x smaller than CSV
# - Typed: no type re-guessing on read
# - Partitioned: split by date/region for parallel reads

cat('Parquet is the modern standard for large-scale analytics in R!')

Scrittura dei dati in una pipeline

Sia write_csv() sia saveRDS() restituiscono il proprio input in modo invisibile, quindi possono essere utilizzati all'interno di una pipe senza interromperne il flusso. Inserisca un passaggio di scrittura a metà della pipeline con write_csv() come punto di controllo per garantire la riproducibilità.

library(readr)
library(dplyr)

# Write mid-pipeline as a checkpoint
final_result <- data.frame(
  region=c('East','West','North'),
  sales=c(100,200,80)
) %>%
  mutate(pct = round(100*sales/sum(sales),1)) %>%
  {. ->> checkpoint_df; .} %>%  # Save checkpoint
  filter(sales > 90)

write_csv(checkpoint_df, '/tmp/checkpoint.csv')
print(final_result)

Guida alla scelta del formato

La scelta del formato di output corretto dipende dall'obiettivo:

  • CSV/TSV: universali, leggibili dall'uomo, apribili da chiunque
  • RDS: da R a R, preserva esattamente tutti i tipi e gli attributi
  • xlsx: utenti aziendali, utenti di Excel
  • Parquet: grandi quantità di dati, pipeline di analisi, sistemi di produzione
  • JSON: API, dati annidati o gerarchici (jsonlite::toJSON())
library(readr)

df <- data.frame(
  id = 1:5,
  value = c(10.5, 20.3, 15.7, 30.1, 25.8)
)

# CSV — universal
write_csv(df, '/tmp/data.csv')

# TSV — when commas are in data
write_tsv(df, '/tmp/data.tsv')

# RDS — R-native, type-preserving
saveRDS(df, '/tmp/data.rds')

cat('Files created:\n')
cat('CSV size:', file.size('/tmp/data.csv'), 'bytes\n')
cat('RDS size:', file.size('/tmp/data.rds'), 'bytes\n')

Verifica rapida

Qual è il principale vantaggio di saveRDS() rispetto a write_csv() per salvare dati R?

Riepilogo: scrittura dei dati

Punti chiave per scrivere dati da R:

  • write_csv(df, 'file.csv') — separato da virgole, senza nomi delle righe, UTF-8
  • write_tsv(df, 'file.tsv') — output separato da tabulazioni
  • write_delim(df, file, delim='|') — qualsiasi delimitatore
  • saveRDS(obj, 'file.rds') — formato binario R, preserva tutti i tipi
  • readRDS('file.rds') — ripristina con qualsiasi nome; load() ripristina i nomi originali
  • writexl::write_xlsx() — output Excel, senza necessità di Java
  • arrow::write_parquet() — formato colonnare per grandi dataset analitici
library(readr)

df <- data.frame(
  name = c('Alice','Bob','Carol'),
  score = c(85.5, 92.0, 78.3),
  grade = factor(c('B','A','C'))
)

# CSV: universal but loses factor
write_csv(df, '/tmp/demo.csv')
df_csv <- read_csv('/tmp/demo.csv', show_col_types=FALSE)
cat('CSV grade type:', class(df_csv$grade), '\n')  # character

# RDS: preserves factor
saveRDS(df, '/tmp/demo.rds')
df_rds <- readRDS('/tmp/demo.rds')
cat('RDS grade type:', class(df_rds$grade))  # factor

Domande Frequenti

La lezione «Scrittura dei dati in più formati» è gratuita?

Sì — il testo completo di «Scrittura dei dati in più formati» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Scrittura dei dati in più formati»?

Esporti data frame in CSV, Excel e RDS con write_csv() e writexl. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Scrittura dei dati in più formati»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Lettura di file CSV con read_csv()
  2. Analisi di file TSV e a larghezza fissa
  3. Importazione di file Excel con readxl
  4. Scrittura dei dati in più formati
← Torna a R Academy