R Language
I / O per tabelle esterne (Excel, SAS, SPSS, Stata)

Importazione di dati con Rio

Un modo molto semplice per importare i dati da molti formati di file comuni è con rio . Questo pacchetto fornisce una funzione import() che racchiude molte funzioni di importazione dei dati comunemente utilizzate, fornendo in tal modo un'interfaccia standard. Funziona semplicemente passando un nome file o URL per import() :

import("example.csv")       # comma-separated values
import("example.tsv")       # tab-separated values
import("example.dta")       # Stata
import("example.sav")       # SPSS
import("example.sas7bdat")  # SAS
import("example.xlsx")      # Excel

import() può anche leggere da directory compresse, URL (HTTP o HTTPS) e dagli appunti. Un elenco completo di tutti i formati di file supportati è disponibile nel repository github del pacchetto rio .

È anche possibile specificare alcuni ulteriori parametri relativi al formato di file specifico che si sta tentando di leggere, passandoli direttamente all'interno della funzione import() :

import("example.csv", format = ",") #for csv file where comma is used as separator
import("example.csv", format = ";") #for csv file where semicolon is used as separator

Importazione di file Excel

Esistono diversi pacchetti R per leggere i file excel, ognuno dei quali utilizza lingue o risorse diverse, come riepilogato nella seguente tabella:

Per i pacchetti che utilizzano Java o ODBC è importante conoscere i dettagli del sistema in quanto potrebbero verificarsi problemi di compatibilità a seconda della versione R e del sistema operativo. Ad esempio, se si utilizzano R 64 bit, è necessario disporre di Java 64 bit per utilizzare xlsx o XLconnect .

Di seguito sono riportati alcuni esempi di lettura dei file excel con ciascun pacchetto. Si noti che molti dei pacchetti hanno nomi di funzioni uguali o molto simili. Pertanto, è utile dichiarare esplicitamente il pacchetto, come package::function . Il pacchetto openxlsx richiede l'installazione precedente di RTools.

Leggendo i file excel con il pacchetto xlsx

library(xlsx)

L'indice o il nome del foglio è richiesto per l'importazione.

xlsx::read.xlsx("Book1.xlsx", sheetIndex=1)

xlsx::read.xlsx("Book1.xlsx", sheetName="Sheet1")

Lettura dei file Excel con il pacchetto XLconnect

library(XLConnect)
wb <- XLConnect::loadWorkbook("Book1.xlsx")

# Either, if Book1.xlsx has a sheet called "Sheet1":
sheet1 <- XLConnect::readWorksheet(wb, "Sheet1")
# Or, more generally, just get the first sheet in Book1.xlsx:
sheet1 <- XLConnect::readWorksheet(wb, getSheets(wb)[1])

XLConnect importa automaticamente gli stili di cella Excel predefiniti incorporati in Book1.xlsx . Ciò è utile quando si desidera formattare l'oggetto cartella di lavoro ed esportare un documento Excel perfettamente formattato. Innanzitutto, è necessario creare i formati di cella desiderati in Book1.xlsx e salvarli, ad esempio myHeader , myBody e myPcts . Quindi, dopo aver caricato la cartella di lavoro in R (vedi sopra):

Headerstyle <- XLConnect::getCellStyle(wb, "myHeader")
Bodystyle <- XLConnect::getCellStyle(wb, "myBody")
Pctsstyle <- XLConnect::getCellStyle(wb, "myPcts")

Gli stili di cella sono ora salvati nell'ambiente R Per assegnare gli stili di cella a determinati intervalli di dati, è necessario definire l'intervallo e quindi assegnare lo stile:

Headerrange <- expand.grid(row = 1, col = 1:8)
Bodyrange <- expand.grid(row = 2:6, col = c(1:5, 8))
Pctrange <- expand.grid(row = 2:6, col = c(6, 7))

XLConnect::setCellStyle(wb, sheet = "sheet1", row = Headerrange$row,
             col = Headerrange$col, cellstyle = Headerstyle)
XLConnect::setCellStyle(wb, sheet = "sheet1", row = Bodyrange$row,
             col = Bodyrange$col, cellstyle = Bodystyle)
XLConnect::setCellStyle(wb, sheet = "sheet1", row = Pctrange$row,
             col = Pctrange$col, cellstyle = Pctsstyle)

Si noti che XLConnect è facile, ma può diventare estremamente lento nella formattazione. Un'opzione di formattazione molto più veloce, ma più ingombrante è offerta da openxlsx .

Leggendo i file excel con il pacchetto openxlsx

I file Excel possono essere importati con il pacchetto openxlsx

library(openxlsx)

openxlsx::read.xlsx("spreadsheet1.xlsx", colNames=TRUE, rowNames=TRUE)

#colNames: If TRUE, the first row of data will be used as column names.
#rowNames: If TRUE, first column of data will be used as row names.

Il foglio, che deve essere letto in R, può essere selezionato fornendo la sua posizione nell'argomento sheet :

openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = 1)

o dichiarando il suo nome:

openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1")

Inoltre, openxlsx può rilevare colonne di date in un foglio letto. Per consentire il rilevamento automatico delle date, un argomento detectDates deve essere impostato su TRUE :

openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1", detectDates= TRUE)

Leggendo i file excel con il pacchetto readxl

I file Excel possono essere importati come frame di dati in R usando il pacchetto readxl .

library(readxl)

Può leggere entrambi i file .xls e .xlsx .

readxl::read_excel("spreadsheet1.xls")
readxl::read_excel("spreadsheet2.xlsx")

Il foglio da importare può essere specificato per numero o nome.

readxl::read_excel("spreadsheet.xls", sheet = 1)
readxl::read_excel("spreadsheet.xls", sheet = "summary")

L'argomento col_names = TRUE imposta la prima riga come nome della colonna.

 readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE)

L'argomento col_types può essere usato per specificare i tipi di colonna nei dati come vettore.

readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE,
                   col_types = c("text", "date", "numeric", "numeric"))

Lettura dei file excel con il pacchetto RODBC

I file Excel possono essere letti utilizzando il driver ODBC Excel che si interfaccia con l'Access Database Engine (ACE) di Windows, in precedenza JET. Con il pacchetto RODBC, R può connettersi a questo driver e interrogare direttamente le cartelle di lavoro. Si presume che i fogli di lavoro mantengano le intestazioni delle colonne nella prima riga con i dati in colonne organizzate di tipi simili. NOTA: questo approccio è limitato alle sole macchine Windows / PC poiché i file JET / ACE sono installati .dll e non disponibili su altri sistemi operativi.

library(RODBC)

xlconn <- odbcDriverConnect('Driver={Microsoft Excel Driver (*.xls, *.xlsx, *.xlsm, *.xlsb)};
                             DBQ=C:\\Path\\To\\Workbook.xlsx')

df <- sqlQuery(xlconn, "SELECT * FROM [SheetName$]")
close(xlconn)

Collegandosi con un motore SQL in questo approccio, i fogli di lavoro Excel possono essere interrogati in modo simile alle tabelle del database, comprese le operazioni JOIN e UNION . La sintassi segue il dialetto JET / ACE SQL. NOTA: solo le istruzioni DML di accesso ai dati, in particolare SELECT possono essere eseguite su cartelle di lavoro, considerate query non aggiornabili.

joindf <-  sqlQuery(xlconn, "SELECT t1.*, t2.* FROM [Sheet1$] t1
                             INNER JOIN [Sheet2$] t2
                             ON t1.[ID] = t2.[ID]")

uniondf <-  sqlQuery(xlconn, "SELECT * FROM [Sheet1$]
                              UNION  
                              SELECT * FROM [Sheet2$]")

Anche altre cartelle di lavoro possono essere interrogate dallo stesso canale ODBC che punta a una cartella di lavoro corrente:

otherwkbkdf <- sqlQuery(xlconn, "SELECT * FROM 
                                 [Excel 12.0 Xml;HDR=Yes;
                                 Database=C:\\Path\\To\\Other\\Workbook.xlsx].[Sheet1$];")

Lettura dei file excel con il pacchetto gdata

esempio qui

Leggere e scrivere file Stata, SPSS e SAS

I pacchetti foreign e haven possono essere utilizzati per importare ed esportare file da una varietà di altri pacchetti statistici come Stata, SPSS e SAS e il relativo software. Esiste una funzione di read per ciascuno dei tipi di dati supportati per importare i file.

# loading the packages
library(foreign)
library(haven)
library(readstata13)
library(Hmisc)

Alcuni esempi per i tipi di dati più comuni:

# reading Stata files with `foreign`
read.dta("path\to\your\data")
# reading Stata files with `haven`
read_dta("path\to\your\data")

Il pacchetto foreign può leggere nei file stato (.dta) per le versioni di Stata 7-12. Secondo la pagina di sviluppo, read.dta è più o meno congelato e non verrà aggiornato per la lettura nelle versioni 13+. Per versioni più recenti di Stata, è possibile utilizzare il pacchetto readstata13 o il haven . Per readstata13 , i file sono

# reading recent Stata (13+) files with `readstata13`
read.dta13("path\to\your\data")

Per la lettura nei file SPSS e SAS

# reading SPSS files with `foreign`
read.spss("path\to\your\data.sav", to.data.frame = TRUE)
# reading SPSS files with `haven`
read_spss("path\to\your\data.sav")
read_sav("path\to\your\data.sav")
read_por("path\to\your\data.por")

# reading SAS files with `foreign`
read.ssd("path\to\your\data")
# reading SAS files with `haven`
read_sas("path\to\your\data")
# reading native SAS files with `Hmisc`
sas.get("path\to\your\data")   #requires access to saslib 
# Reading SA XPORT format ( *.XPT ) files
sasxport.get("path\to\your\data.xpt")  # does not require access to SAS executable

Il pacchetto SAScii fornisce funzioni che accettano il codice di importazione SAS SET e costruiscono un file di testo che può essere elaborato con read.fwf . Si è dimostrato molto robusto per l'importazione di grandi set di dati rilasciati dal pubblico. Il supporto è disponibile all'indirizzo https://github.com/ajdamico/SAScii

Per esportare i frame di dati in altri pacchetti statistici, è possibile utilizzare le funzioni di scrittura write.foreign() . Questo scriverà 2 file, uno contenente i dati e uno contenente le istruzioni che l'altro pacchetto ha bisogno di leggere i dati.

# writing to Stata, SPSS or SAS files with `foreign`
write.foreign(dataframe, datafile, codefile,
              package = c("SPSS", "Stata", "SAS"), ...)
write.foreign(dataframe, "path\to\data\file", "path\to\instruction\file", package = "Stata")

# writing to Stata files with `foreign`
write.dta(dataframe, "file", version = 7L,
          convert.dates = TRUE, tz = "GMT",
          convert.factors = c("labels", "string", "numeric", "codes"))

# writing to Stata files with `haven`
write_dta(dataframe, "path\to\your\data")

# writing to Stata files with `readstata13`
save.dta13(dataframe, file, data.label = NULL, time.stamp = TRUE,
  convert.factors = TRUE, convert.dates = TRUE, tz = "GMT",
  add.rownames = FALSE, compress = FALSE, version = 117,
  convert.underscore = FALSE)

# writing to SPSS files with `haven`
write_sav(dataframe, "path\to\your\data")

Il file memorizzato da SPSS può anche essere letto con read.spss in questo modo:

 foreign::read.spss('data.sav', to.data.frame=TRUE, use.value.labels=FALSE, 
                     use.missings=TRUE, reencode='UTF-8')
# to.data.frame if TRUE: return a data frame
# use.value.labels if TRUE: convert variables with value labels into R factors with those levels
# use.missings if TRUE: information on user-defined missing values will used to set the corresponding values to NA.
# reencode character strings will be re-encoded to the current locale. The default, NA, means to do so in a UTF-8 locale, only.

Importazione o esportazione di file Feather

Feather è un'implementazione di Apache Arrow progettata per archiviare i frame di dati in un linguaggio agnostico mantenendo i metadati (ad es. Le classi di date), aumentando l'interoperabilità tra Python e R. La lettura di un file feather produrrà un tibble, non un data.frame standard.

library(feather)

path <- "filename.feather"
df <- mtcars

write_feather(df, path)

df2 <- read_feather(path)

head(df2)
##  A tibble: 6 x 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21.0     6   160   110  3.90 2.620 16.46     0     1     4     4
## 2  21.0     6   160   110  3.90 2.875 17.02     0     1     4     4
## 3  22.8     4   108    93  3.85 2.320 18.61     1     1     4     1
## 4  21.4     6   258   110  3.08 3.215 19.44     1     0     3     1
## 5  18.7     8   360   175  3.15 3.440 17.02     0     0     3     2
## 6  18.1     6   225   105  2.76 3.460 20.22     1     0     3     1

head(df)
##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

La documentazione attuale contiene questo avvertimento:

Nota per gli utenti: la piuma deve essere trattata come un software alfa. In particolare, è probabile che il formato del file si evolva nel corso del prossimo anno. Non utilizzare Feather per l'archiviazione dei dati a lungo termine.