R Language
E / S para tablas externas (Excel, SAS, SPSS, Stata)

Importando datos con rio

Una forma muy sencilla de importar datos desde muchos formatos de archivo comunes es con rio . Este paquete proporciona una función de import() que envuelve muchas de las funciones de importación de datos más utilizadas, proporcionando así una interfaz estándar. Funciona simplemente al pasar un nombre de archivo o URL para 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() también puede leer directorios comprimidos, URL (HTTP o HTTPS) y el portapapeles. Una lista completa de todos los formatos de archivo admitidos está disponible en el repositorio github del paquete rio .

Incluso es posible especificar algunos parámetros adicionales relacionados con el formato de archivo específico que está intentando leer, pasándolos directamente dentro de la función 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

Importando archivos de Excel

Hay varios paquetes R para leer archivos de Excel, cada uno de los cuales utiliza diferentes idiomas o recursos, como se resume en la siguiente tabla:

Para los paquetes que usan Java u ODBC, es importante conocer los detalles de su sistema porque puede tener problemas de compatibilidad dependiendo de su versión R y sistema operativo. Por ejemplo, si está utilizando R 64 bits, también debe tener Java 64 bits para usar xlsx o XLconnect .

A continuación se proporcionan algunos ejemplos de cómo leer archivos de Excel con cada paquete. Tenga en cuenta que muchos de los paquetes tienen nombres de funciones iguales o muy similares. Por lo tanto, es útil indicar el paquete explícitamente, como package::function . El paquete openxlsx requiere la instalación previa de RTools.

Leyendo archivos de excel con el paquete xlsx

library(xlsx)

El índice o nombre de la hoja se requiere para importar.

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

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

Leyendo archivos de Excel con el paquete 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 automáticamente los estilos de celda de Excel predefinidos incrustados en Book1.xlsx . Esto es útil cuando desea formatear el objeto de su libro de trabajo y exportar un documento de Excel perfectamente formateado. Primero, deberá crear los formatos de celda deseados en Book1.xlsx y guardarlos, por ejemplo, como myHeader , myBody y myPcts . Luego, después de cargar el libro de trabajo en R (ver arriba):

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

Los estilos de celda ahora se guardan en su entorno R Para asignar los estilos de celda a ciertos rangos de sus datos, debe definir el rango y luego asignar el estilo:

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)

Tenga en cuenta que XLConnect es fácil, pero puede tener un formato extremadamente lento. openxlsx ofrece una opción de formato mucho más rápida, pero más engorrosa.

Leyendo archivos de excel con el paquete openxlsx

Los archivos de Excel se pueden importar con el paquete 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.

La hoja, que debe leerse en R puede seleccionarse al proporcionar su posición en el argumento de la sheet :

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

o declarando su nombre:

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

Además, openxlsx puede detectar columnas de fecha en una hoja de lectura. Para permitir la detección automática de fechas, un argumento detectDates debe establecer en TRUE :

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

Leyendo archivos de excel con el paquete readxl

Los archivos de Excel se pueden importar como un marco de datos en R usando el paquete readxl .

library(readxl)

Puede leer archivos .xls y .xlsx .

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

La hoja a importar se puede especificar por número o nombre.

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

El argumento col_names = TRUE establece la primera fila como nombres de columna.

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

El argumento col_types se puede usar para especificar los tipos de columna en los datos como un vector.

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

Leyendo archivos de excel con el paquete RODBC

Los archivos de Excel se pueden leer utilizando el controlador ODBC Excel que interactúa con el motor de base de datos de acceso de Windows (ACE), anteriormente JET. Con el paquete RODBC, R puede conectarse a este controlador y consultar libros directamente. Se asume que las hojas de trabajo mantienen los encabezados de columna en la primera fila con datos en columnas organizadas de tipos similares. NOTA: Este enfoque se limita a que solo las máquinas con Windows / PC, ya que JET / ACE, tienen archivos .dll instalados y no están disponibles en otros sistemas operativos.

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)

Al conectarse con un motor SQL en este enfoque, las hojas de cálculo de Excel pueden consultarse de manera similar a las tablas de base de datos, incluidas las operaciones de JOIN y UNION . La sintaxis sigue el dialecto JET / ACE SQL. NOTA: Solo las declaraciones DML de acceso a datos, específicamente SELECT pueden ejecutarse en libros de trabajo, consideradas consultas no actualizables.

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

Incluso se pueden consultar otros libros desde el mismo canal ODBC que apunta a un libro actual:

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

Leyendo archivos de excel con el paquete gdata

ejemplo aquí

Lee y escribe archivos Stata, SPSS y SAS

Los paquetes foreign y haven se pueden usar para importar y exportar archivos de una variedad de otros paquetes estadísticos como Stata, SPSS y SAS y el software relacionado. Hay una función de read para cada uno de los tipos de datos compatibles para importar los archivos.

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

Algunos ejemplos para los tipos de datos más comunes:

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

El paquete foreign puede leer archivos stata (.dta) para versiones de Stata 7-12. De acuerdo con la página de desarrollo, read.dta está más o menos congelado y no se actualizará para leer en las versiones 13+. Para versiones más recientes de Stata, puede usar el paquete readstata13 o haven . Para readstata13 , los archivos son

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

Para leer en archivos SPSS y 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

El paquete SAScii proporciona funciones que aceptarán el código de importación SAS SET y construirán un archivo de texto que se puede procesar con read.fwf . Ha demostrado ser muy robusto para la importación de grandes conjuntos de datos publicados públicamente. El soporte se encuentra en https://github.com/ajdamico/SAScii

Para exportar marcos de datos a otros paquetes estadísticos, puede utilizar las funciones de escritura write.foreign() . Esto escribirá 2 archivos, uno que contiene los datos y otro que contiene las instrucciones que el otro paquete necesita para leer los datos.

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

El archivo almacenado por el SPSS también se puede leer con read.spss de esta manera:

 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.

Importación o exportación de archivo Feather

Feather es una implementación de Apache Arrow diseñada para almacenar marcos de datos de una manera independiente del lenguaje mientras se mantienen los metadatos (por ejemplo, clases de fecha), lo que aumenta la interoperabilidad entre Python y R. La lectura de un archivo de plumas producirá un tibble, no un cuadro de datos estándar.

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 documentación actual contiene esta advertencia:

Nota para los usuarios: Feather debe tratarse como un software alfa. En particular, es probable que el formato del archivo evolucione durante el próximo año. No utilice Feather para el almacenamiento de datos a largo plazo.