Importar datos en R - parte dos

En este segundo tutorial tras This R Data Import Tutorial Is Everything You Need-Part One, DataCamp continúa con una guía completa pero sencilla para importar datos en R rápidamente, desde archivos de texto planos hasta ficheros más avanzados de SPSS y SAS.

Como muchos lectores detectaron en el primer artículo, aún quedaban paquetes estupendos para importar datos en R por cubrir, y tampoco se explicitó la diferencia entre trabajar con conjuntos de datos estándar y conjuntos de gran tamaño. Por eso, ese será el foco de la publicación de hoy.

Sigue leyendo para descubrir otras formas (y algunas nuevas) de importar tu archivo en R, y no dudes en contactarnos si tienes más preguntas o detectas algún error que debamos corregir.

(Prueba este curso interactivo: Importing Data in R (Part 1), para trabajar con archivos CSV y Excel en R).

Traer datos de fuentes habituales a R

Para empezar, este artículo profundiza en cómo llevar a R datos de fuentes comunes, normalmente datos con formato de hoja de cálculo. Igual que en el post anterior, el foco será leer datos en R distintos de Excel u otros tipos de archivos.

Después, se tratarán datos de otras fuentes como software estadístico, bases de datos, web scraping, etc.

Si quieres saber más sobre los pasos previos que quizá necesites antes de importar tus datos, visita nuestro primer artículo, que explica cómo preparar tus datos y tu espacio de trabajo antes de traerlos a R.

Leer archivos planos en R con scan()

Además de read.table(), que se mencionó en el primer artículo del tutorial, la función scan() también sirve para manejar datos almacenados en archivos de texto delimitado sencillos. A diferencia de read.table(), scan() devuelve una lista o un vector, no un data frame.

Supón que tienes este documento .txt:

24 1991
21 1993
53 1962

Puedes leer los datos (puedes descargarlos aquí) con el siguiente comando:

data <- scan("birth.txt")

Nota: tu archivo también puede ser un conjunto de datos online. En ese caso, pasa la URL como primer argumento de scan().

De forma alternativa, también puedes leer los datos en una matriz:

data <- matrix(scan("birth.txt"),
               nrow=2,
               byrow=TRUE)

Truco: si quieres hacerlo bien, quizá necesites especificar argumentos adicionales para construir la matriz como quieras. Visita esta página para más información sobre matrix().

También puedes leer las columnas del archivo de entrada en vectores separados:

data <- scan("age.txt",
             what = list(Age = 0,
                         Birthyear= 0),
             skip=1,
             quiet=TRUE)

Fíjate en que primero pasas el archivo (o su ruta) con su extensión (según hayas definido o no el directorio de trabajo en la carpeta que contiene tu dataset) y después especificas el tipo de datos a leer, si quieres omitir la primera línea del dataset, qué carácter delimita los campos y si quieres imprimir una línea indicando cuántos elementos se han leído.

Si tus datos pueden contener otros tipos, tendrás que ajustar un poco scan(), como en este ejemplo:

data <- scan("age.csv",
             what = list(Age = 0,
                         Name= "",
                         Birthyear= 0),
             skip=1,
             sep=";",
             quiet=TRUE)

Truco: ¡puedes probarlo tú mismo! Descarga el archivo de texto usado arriba aquí.

Y también puedes leer los datos en un data frame:

data <- data.frame(scan("age.csv",
                        what = list(Age = 0,
                                    Name = "",
                                    Birthyear= 0),
                        skip=1,
                        sep=";",
                        quiet=TRUE)

Truco: muchos de los argumentos que acepta scan() son los mismos que puedes usar con read.table(). ¡Por eso siempre conviene consultar la documentación! Ve aquí si quieres repasar los argumentos de scan().

Recuerda que puedes obtener y establecer el directorio de trabajo con estos comandos, respectivamente:

getwd()
setwd("<path to your folder>")

Importar datos de columnas fijas en R con read.fwf()

Para leer una tabla de datos con ancho de columna fijo en un data frame en R, puedes usar la función read.fwf() del paquete utils.

Usa esta función cuando tu archivo tiene columnas con espacios internos o columnas sin separadores entre ellas.

   Phys / 00 / 1:    M  abadda
   Math / 00 / 2:    F  bcdccb
   Lang / 00 / 3:    F  abcdab
   Chem / 00 / 4:    M  cdabaa

Aquí sabes, por ejemplo, que la asignatura siempre ocupa los 7 primeros caracteres de cada línea, el valor de sexo está siempre en la posición 22 y las puntuaciones van del carácter 25 al 30.

Si quieres probar a cargar estos datos en R, puedes descargar el archivo de texto aquí.

Necesitarías ejecutar este comando para traer correctamente los datos anteriores a R:

read.fwf("scores.txt",
         widths= c(7,-14,1,-2,1,1,1,1,1,1),
         col.names=c("subject","sex","s1","s2","s3","s4","s5","s6"),
         strip.white=TRUE)

Nota: el argumento widths indica los anchos de los campos de anchura fija. En este caso, los siete primeros caracteres del archivo están reservados para los nombres de las asignaturas; luego, no quieres leer los catorce siguientes: pasas -14. Después, necesitas un carácter para el sexo, pero no quieres los dos siguientes, así que pasas -2. Todos los caracteres restantes se leen en columnas separadas, por eso los divides pasando 1,1,1,1,1,1 al argumento. Por supuesto, estos valores variarán según qué columnas quieras importar.

Hay más argumentos que puedes pasar a read.fwf(). Haz clic aquí para leer sobre ellos.

Nota: si quieres cargar un archivo usando especificaciones de formato tipo Fortran, puedes usar la función read.fortran():

data <- tempfile()
cat(file = data, "345678", "654321", sep = "\n")
read.fortran(data, c("F2.1","F2.0","I2"))

Como ves en el ejemplo, usas especificaciones de formato estilo Fortran como segundo argumento de read.fortran(). Los argumentos que puedes pasar siguen el estilo: “rFl.d”, “rDl.d”, “rXl”, “rAl” o “rIl”, donde “l” es el número de columnas, “d” el número de decimales y “r” el número de repeticiones. En este caso, verás 2.1, 2.0 y 2 listados mediante c(), lo que implica tres columnas con dos filas. En la primera columna hay valores con un decimal; en la segunda y la tercera, valores sin decimales.

En cuanto al tipo de valores por columna, puedes tener:

• “F” y “D” para formatos numéricos;
• “A” para valores de texto;
• “I” para enteros;
• Y “X” para indicar columnas a omitir.

En este caso, las dos primeras columnas contendrán formatos numéricos y la tercera, valores enteros.

Nota: los códigos de repetición “r” y de decimales “d” son opcionales. El código de longitud “l” es obligatorio salvo en formatos “X” cuando “r” está presente.

Importar tus hojas de cálculo (Google) en R

Las hojas de cálculo se pueden importar a R de varias maneras, como quizá ya leíste en nuestro tutorial sobre leer e importar archivos de Excel en R o en nuestro primer artículo This R Data Import Tutorial Is Everything You Need. Esta sección amplía y va más allá, incluyendo también hojas de Google y archivos DIF.

Sigue leyendo para descubrir cómo importar tus hojas de cálculo en R.

Importar hojas de Excel en R

Además del paquete xlsx, tienes otras opciones para leer hojas de cálculo en R:

1. Leer hojas de Excel en R desde el portapapeles

Si tienes una hoja abierta, puedes copiar su contenido al portapapeles e importarlo rápidamente en R. Para ello, usa readClipboard() o read.table():

readClipboard() #Only on Windows
read.table(file="clipboard")`

Verás que el primer enfoque funciona bien con datos vectoriales, pero se complica si tienes datos tabulares en el portapapeles. Si quieres saber más sobre read.table(), ve sin falta a la primera parte del tutorial o a nuestro artículo sobre leer e importar Excel en R.

2. Leer hojas de Excel en R con el paquete RODBC

La segunda forma de traer tus hojas de Excel a R es con el paquete RODBC:

• Una primera manera de usar este paquete es así:

library(RODBC)
connection <- odbcConnect("<DSN>")

Nota: el argumento que pasas a odbcConnect() es un DSN. Para una guía completa sobre cómo configurar tu DSN, crear la conexión, etc., visita esta página, ¡un tutorial extenso pero muy ameno!

• Una vez establecida la conexión, también puedes usar sqlQuery() para obtener datos de hojas .xls:

query <- "<SQL Query>"
data <- sqlQuery(connection,
                 query)
str(data)

Supertruco: visita esta página, ¡un tutorial extenso pero muy accesible!

Al terminar tu sesión en R, no olvides cerrar las conexiones:

odbcCloseAll()

Truco: si quieres saber más sobre cómo importar hojas o archivos de Excel en R, vuelve a nuestro primer tutorial sobre importar datos en R o echa un vistazo a nuestro artículo sobre leer e importar Excel en R, que trata paquetes como readxl y XLConnect, entre otros.

Importar hojas de Google en R

El paquete googlesheets con su función gs_read() te permite leer hojas de Google en R.

Empieza ejecutando esta línea:

gs_ls()

Deja que se abra el navegador y completa la autenticación. Luego, si quieres leer o editar los datos, tienes que registrar la hoja. Puedes hacerlo indicando el título o la clave:

data <- gs_title("<your spreadsheet>")
data <- gs_key()

Después, puedes leer los datos:

gs_read(data)

Esto es solo una visión rápida de lo que puedes hacer con googlesheets. Lee todos los detalles aquí, y no te pierdas esta página.

Leer archivos DIF (Data Interchange Format) en R

Usa la función read.DIF() para traer tus archivos DIF a R:

data <- read.DIF("<your spreadsheet>",
                 header=FALSE,
                 as.is = !stringsAsFactors)

Nota: puedes indicar si tu hoja tiene cabecera o no y si quieres importar los datos “tal cual”, es decir, si quieres convertir variables de texto a factores. En este caso no lo querías, así que indicaste !stringsAsFactors.

Para más información sobre esta función o sus argumentos, ve a esta página.

Traer archivos de Excel a R

Además de hojas de cálculo, quizá te interese importar tus archivos de Excel como tal en R. Sigue leyendo para ver cómo hacerlo.

Nota: este artículo amplía lo descrito en nuestro tutorial sobre leer e importar Excel en R y en el primer post This R Data Import Tutorial Is Everything You Need.

Importar archivos de Excel en R con readxl

Aunque este paquete sigue en desarrollo activo, merece la pena probarlo porque te ofrece una forma muy sencilla de leer archivos de Excel:

library(readxl)
read_excel("<path to file")

Recuerda que basta con escribir el nombre del archivo y su extensión si la carpeta está en tu directorio de trabajo. Obtén y establece el directorio con:

getwd()
setwd("<Path to your folder>")

Nota: puedes especificar la hoja a leer, los nombres y tipos de columnas, los valores perdidos y el número de filas a omitir antes de leer con los argumentos sheet, col_names, col_types, na y skip, respectivamente. Más info aquí.

Leer archivos de Excel en R con openxlsx

El paquete openxlsx también te ofrece una forma sencilla de leer archivos .xlsx en R:

library(openxlsx)
read.xlsx("<path to your file>")

Si quieres más detalles sobre este paquete o los argumentos de read.xlsx(), haz clic aquí.

Truco: para saber más sobre cómo importar Excel en R, vuelve a nuestro primer tutorial sobre “importar datos en R” o lee nuestro tutorial completo sobre leer e importar Excel en R, que también trata el paquete XLConnect, entre otros.

Importar hojas de OpenDocument en R

Usa la función read.ods() del paquete readODS para leer tus hojas de OpenDocument en R y volcarlas en data frames:

library(readODS)
read.ods("<path to your file>",
         sheet = 1,
         formulaAsFormula = FALSE)

Nota: además del archivo a importar, puedes indicar la hoja y si quieres mostrar las fórmulas como tales (por ejemplo, “SUM(B1:B3)”) o los valores resultantes.

Importar archivos JSON (JavaScript Object Notation) en R

En nuestro primer artículo sobre importar datos en R, mencionamos el paquete rjson para traer archivos JSON a R.

No obstante, hay otros paquetes con los que puedes importar JSON en R. ¡Sigue leyendo!

Importar JSON en R con el paquete jsonlite

Recientemente situado en el top 25 de paquetes de R más descargados con 66.952 descargas, el paquete jsonlite es sin duda uno de los favoritos de la comunidad.

Importas archivos JSON con la función fromJSON():

library(jsonlite)
data <- fromJSON("<Path to your JSON file>")

Para un inicio rápido bien explicado con jsonlite, ve aquí.

Importar JSON en R con el paquete RJSONIO

El tercer paquete conocido para traer JSON a R es RJSONIO. Igual que con jsonlite, usas la función fromJSON():

library(RJSONIO)
data <- fromJSON("<Path to your JSON file")

¿El mejor paquete para JSON?

Se ha debatido bastante sobre este tema. Si quieres saber más, echa un vistazo a estas páginas y posts:

• esta página ofrece sobre todo ejemplos de código que ayudan a entender el comportamiento y rendimiento de los paquetes de JSON en R.
• No te pierdas este artículo, que intenta averiguar qué paquete gestiona mejor JSON en R.

Traer datos de paquetes de software estadístico a R

Si tus datos no son tipo hoja de cálculo y no están en Excel o JSON, quizá procedan de alguno de los muchos paquetes de software estadístico.

Esta sección te da más formas de leer archivos de SPSS, Stata o SAS, y también un repaso para importar ficheros de S-plus y Epi Info. Vuelve a nuestro primer artículo o a los enlaces inferiores si quieres ampliar.

Importar archivos de SPSS en R

En lugar de usar el paquete foreign, también puedes recurrir a haven para traer tus archivos de SPSS a R.

Recuerda instalarlo y activarlo en tu sesión antes de empezar.

El paquete haven ofrece la función read_spss() para leer ficheros de SPSS en R:

library(haven)
data <- read_spss("<path to your SPSS file>")

Importar archivos de Stata en R

Al igual que foreign, el paquete haven también proporciona una función para leer archivos de Stata en R, read_dta():

data <- read_dta("<path to your STATA file>")

Recuerda instalar los paquetes cuando sea necesario y activarlos en tu sesión. Por ejemplo, puedes instalar y cargar haven con:

install.packages("haven")
library(haven)

Importar archivos de SAS en R

Como en el último artículo citamos sas7bdat, en este vamos a centrarnos en otras formas de leer archivos de SAS:

1. Cómo importar archivos SAS XPORT en R con foreign

El paquete foreign con la función read.xport() también te permite cargar archivos SAS XPORT en R:

library(foreign)
data <- read.xport("<path to your SAS file>")

2. Cómo importar archivos SAS XPORT en R con SASxport

El paquete sasXPORT también permite leer archivos SAS XPORT con read.xport():

library(SASxport)
data <- read.xport("<path to your SAS file>")

3. Cómo importar archivos SAS en R con haven

Igual que foreign y sas7bdat, el paquete haven también permite leer archivos b7dat en R con read_sas():

library(haven)
data <- read_sas("<path to your SAS file>")

Traer archivos de S-plus a R

Para datasets antiguos de S-plus (producidos en Windows 3.x, 4.x o 2000, o Unix 3.x con enteros de 4 bytes), puedes usar read.S() del paquete foreign:

library(foreign)
data <- read.S("<Path to your file>")

Leer archivos de Epi Info en R

Como habrás leído, el paquete foreign ofrece muchas funciones para leer formatos específicos en R, y Epi Info no es una excepción. Usa read.epiinfo() para traer tus datos a R:

library(foreign)
data <- read.epiinfo("<Path to your file>")

Para más información sobre Epi Info, haz clic aquí.

Traer datos de otras fuentes a R

Además de las fuentes habituales y el software estadístico, hay muchas otras fuentes de las que puedes querer leer datos en R.

A continuación, algunas de ellas. ¡Sigue leyendo!

Importar archivos de MATLAB en R

Puedes usar el paquete R.matlab con su función readMat() para importar archivos de MATLAB en R.

Puedes pasar una cadena como primer argumento (se interpreta como nombre de archivo) o un vector raw (se considera una conexión binaria):

library(R.matlab)
data <- readMat("<Path to your file>")

readMat() devuelve una lista con nombre que contiene todas las variables del archivo MAT importado.

Leer archivos de Octave en R

¡Vuelve a aparecer el paquete foreign! Usa read.octave() para importar datos de texto de Octave en R:

library(foreign)
data <- read.octave("<Path to your file>")

Traer datos de FitbitScraper a R

Puedes usar el paquete fitbitScraper para obtener datos de fitbit.

(Para quienes no conozcan la empresa: ofrece pulseras de actividad y otros dispositivos que miden datos personales como pasos realizados o calidad del sueño).

Ve aquí para un tutorial corto y práctico sobre el uso de fitbitScraper.

Importar datos de Quantmod en R

Este paquete te permite extraer datos financieros de Internet con R. La función que usarás es getSymbols(), como en este ejemplo:

library(quantmod)
data <- getSymbols("YHOO", src="google")

Nota: primero especificas un vector de caracteres con los símbolos a cargar, en este caso "YHOO". Luego defines el origen. Los orígenes disponibles son yahoo, google, MySQL, FRED, csv, RData y oanda.

Después, especificas los parámetros de búsqueda y los guardas para futuras sesiones:

setSymbolLookup(YHOO='google',GOOG='yahoo')
saveSymbolLookup(file="mysymbols.rda")

En nuevas sesiones, entonces llamas a

loadSymbolLookup(file="mysymbols.rda")
getSymbols(c("YHOO","GOOG"))

Si quieres más información sobre finanzas cuantitativas en R, haz clic aquí o ve a esta página para un tutorial detallado para principiantes con quantmod.

Traer archivos ARFF a R

Los datos en formato ARFF (Attribute-Relation File Format) de Weka se leen con read.arff():

library(foreign)
data <- read.arff("<Path to your file>")

Para más información, visita esta página.

Nota: el paquete RWeka también ofrece la misma función para importar ARFF. Más info aquí.

Importar datos desde bases de datos en R

Además de MonetDB.R, rmongodb y RMySQL, que se cubrieron en el artículo anterior, también tienes otros paquetes para conectar tus bases de datos en R.

también cuentas con mongolite, RMongo, RODBC, ROracle, RPostgreSQL, RSQLite, RJDBC.

Para tutoriales de estos paquetes, revisa esta lista:

• Para empezar con mongolite, te ayudará este tutorial;
• Para RMongo, puedes ir a este post;
• El paquete RODBC también se trata en este tutorial. Para una versión más breve, ve aquí;
• Para aprender a trabajar con ROracle, consulta esta presentación;
• Para más información sobre RPostgreSQL, ve aquí o aquí;
• No te pierdas este tutorial tan completo si quieres saber más sobre RSQLite;
• Por último, para conectar con SQL Server usando RJDBC, revisa este artículo o ve a esta página si quieres conectar a Oracle. Nota: esta última página también te da otras opciones para conectar con Oracle.

Nota: también existe el paquete de interfaz a bases de datos DBI, que permite la comunicación entre R y sistemas de gestión de bases de datos relacionales. Para más info, haz clic aquí.

Algunas explicaciones sobre cómo trabajar con este paquete están aquí.

Traer archivos binarios a R

Los archivos de datos binarios almacenan información en grupos de dígitos binarios. Cada dígito binario es cero o uno. Ocho dígitos binarios forman un byte. Puedes leer datos binarios con la función readBin():

connection <- file("<path to your file>", "rb") #You open the connection as "reading binary"(rb)
data <- readBin(connection,
                what="numeric") #Mode of the vector to be read

Para un ejemplo más detallado, ve a esta página. Para más información sobre readBin(), haz clic aquí.

Leer formatos binarios en R

Los paquetes hdf5, h5r, rhdf5, RNetCDF, ncdf y ncdf4 proporcionan interfaces para los archivos de datos HDF5 de la NASA y netCDF de UCAR.

Para quienes busquen tutoriales sobre cómo trabajar con HDF5 o netCDF en R, echa un ojo a estos recursos:

• Un excelente tutorial sobre HDF en R, usando también el paquete pathfinder, aquí;
• Un tutorial accesible para principiantes sobre netCDF en R está en esta página.

Traer archivos DBF a R

Un DBF (DataBase File) es el formato subyacente de dBase. Puedes leer archivos DBF con el paquete foreign, que ofrece read.dbf():

library(foreign)
data <- read.dbf("<Path to your file>")

Nota: si usas Windows, también puedes usar RODBC con odbcConnectDbase() para leer DBF vía el controlador ODBC de dBase de Microsoft.

Importar tablas de contingencia planas en R

El paquete foreign permite leer múltiples formatos; las tablas de contingencia “planas” no son una excepción. Usa read.ftable() para ello:

library(foreign)
data <- read.ftable("<Path to your file>")

Recuerda que las tablas de contingencia “planas” son muy similares a las “normales”: contienen los recuentos de cada combinación de niveles de las variables (factores) implicadas. Sin embargo, esta información se reorganiza como una matriz cuyas filas y columnas corresponden a combinaciones únicas de niveles de las variables de fila y columna. Por eso, a menudo se prefieren para representar tablas de contingencia de mayor dimensión.

Leer archivos de sistemas de información geográfica (GIS) en R

Puedes usar los paquetes rgdal y raster, entre otros, para traer tus archivos GIS a R.

Si no tienes claro cómo empezar con rgdal, revisa este buen post, que te introduce al trabajo con datos geoespaciales en R.

También puedes consultar este tutorial, que trabaja con rgdal y raster.

Importar tablas de ITIS (Integrated Taxonomical Information) en R

Puedes importar tablas de ITIS con read.table():

data <- read.table("<Path to your file>")

Para más información sobre ITIS, haz clic aquí.

Importar conjuntos de datos grandes en R

La importación de conjuntos de datos grandes suele generar debate entre usuarios de R. Además de los paquetes para conectar con bases de datos, hay otros que destacan al trabajar con big data.

Importar grandes conjuntos de datos en R con el paquete data.table

Descrito como el “fast and friendly file finagler”, el popular paquete data.table es extremadamente útil y fácil de usar. Su función fread() está pensada para importar datos desde archivos delimitados regulares directamente en R, sin rodeos ni complicaciones.

Nota: “regular” aquí significa que cada fila debe tener el mismo número de columnas. Un ejemplo:

  V1 V2 V3
1  1  6  a
2  2  7  b
3  3  8  c
4  4  9  d
5  5 10  e

Una de las grandes virtudes de esta función es que detecta automáticamente controles como sep, colClasses o nrows. Además, los tipos bit64::integer64 también se detectan y leen directamente, sin necesidad de leer como carácter y luego convertir.

Recuerda que bit64::integer64 son enteros de 64 bits: estos números se almacenan con 64 bits. Por defecto, son de 32 bits. Al detectarse como integer64, el sistema sabe que es un número y no lo lee como texto para convertirlo después.

Un ejemplo de fread() es:

library(data.table)
data <- fread("http://assets.datacamp.com/blog_assets/chol.txt")
data

##      AGE HEIGHT WEIGHT CHOL  SMOKE BLOOD  MORT
##   1:  20    176     77  195 nonsmo     b alive
##   2:  53    167     56  250 sigare     o  dead
##   3:  44    170     80  304 sigare     a  dead
##   4:  37    173     89  178 nonsmo     o alive
##   5:  26    170     71  206 sigare     o alive
##  ---
## 196:  35    174     57  222   pipe     a alive
## 197:  38    172     91  227 nonsmo     b alive
## 198:  26    170     60  167 sigare     a alive
## 199:  39    165     74  259 sigare     o alive
## 200:  49    178     81  275   pipe     b alive

Nota: leer con fread() te devuelve una data table:

str(data)

## Classes 'data.table' and 'data.frame':   200 obs. of  7 variables:
##  $ AGE   : int  20 53 44 37 26 41 39 28 33 39 ...
##  $ HEIGHT: int  176 167 170 173 170 165 174 171 180 166 ...
##  $ WEIGHT: int  77 56 80 89 71 62 75 68 100 74 ...
##  $ CHOL  : int  195 250 304 178 206 284 232 152 209 150 ...
##  $ SMOKE : chr  "nonsmo" "sigare" "sigare" "nonsmo" ...
##  $ BLOOD : chr  "b" "o" "a" "o" ...
##  $ MORT  : chr  "alive" "dead" "dead" "alive" ...
##  - attr(*, ".internal.selfref")=<externalptr>

Esto es diferente a read.table(), que crea un data frame.

Más sobre las diferencias entre data frames y data tables aquí. En resumen, toda data.table es también un data.frame. Una data.table se puede pasar a cualquier paquete que solo acepte data.frames y ese paquete puede usar la sintaxis [.data.frame sobre la data.table. Lee más aquí.

library(data.table)
data <- fread("http://assets.datacamp.com/blog_assets/chol.txt",
              sep=auto,
              nrows = -1,
              na.strings = c("NA","N/A",""),
              stringsAsFactors=FALSE
              )

Nota: la entrada también puede ser un archivo local, no siempre una URL. Observa además que muchos argumentos son los mismos que usas en read.table(), por ejemplo.

Truco: ¿quieres saber más sobre data.table? Quizá te interese nuestro curso Data Analysis In R, The data.table Way. Con la guía de Matt Dowle y Arun Srinivasan, pasarás de principiante a experto en data.table en muy poco tiempo.

Traer grandes conjuntos de datos a R con ff

El paquete ff permite el “almacenamiento eficiente en disco de datos grandes y funciones de acceso rápidas”. Es una de las soluciones que aparece a menudo cuando buscas cómo leer big data como data frames, como aquí.

Si quieres importar archivos planos separados a data frames ff, puedes usar read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() o read.delim2.ffdf(), muy similares a read.table() y sus variantes o envoltorios, descritos en un artículo anterior:

bigdata <- read.table.ffdf(file="<Path to file>",
                           nrows=n)

Nota: tu primer argumento puede ser NULL (como aquí) o un objeto ffdf opcional al que se anexan los registros leídos. Para saber más, ve aquí. Luego nombras el archivo del que se leen los datos con file. También puedes limitar el número de filas a leer con nrows (igual que en read.table()).

También puedes ir más allá y especificar la codificación del archivo, los niveles o el nombre de una función llamada para leer cada bloque:

library(ff)
bigdata <- read.table.ffdf(file="<Path to file>",
                           nrows=n,
                           fileEncoding="",
                           levels=NULL,
                           FUN="read.table")

Truco: más argumentos que puedes añadir a read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() o read.delim2.ffdf() están aquí.

Importar grandes conjuntos de datos en R con bigmemory

Otro paquete que aparece con frecuencia al buscar sobre datos grandes en R es bigmemory. Permite “gestionar matrices masivas con memoria compartida y archivos mapeados en memoria”.

Nota: no puedes usarlo en Windows: no hay binarios para Windows.

library(bigmemory)
bigdata <- read.big.matrix(filename="<File name>",
                           sep="",
                           header=TRUE,
                           skip=2)

Como siempre, primero indicas el nombre del archivo y después especificas otras cosas como el separador, la cabecera o el número de líneas a omitir antes de empezar a leer con sep, header y skip, respectivamente.

Nota: ¡estos son solo algunos ejemplos! Puedes pasar muchos más argumentos a read.big.matrix(). Revisa la documentación si quieres profundizar.

Leer grandes conjuntos de datos en R con el paquete sqldf

El paquete sqldf también es una opción al trabajar con datos grandes. Permite “ejecutar selects de SQL sobre R”, y su función read.csv.sql() es muy útil para leer un archivo en R filtrándolo con una sentencia SQL. Así, solo una parte de los datos es procesada por R:

library(sqldf)
bigdata <- read.csv.sql(file="<Path to your file>",
                        sql="select * from file where ...",
                        colClasses=c("character",
                                     rep("numeric",10)))

Nota: el ejemplo se parece mucho a otras funciones para importar datos grandes, con la única diferencia de que el segundo argumento de read.csv.sql() es una sentencia SQL. Las tablas a las que te refieres en la consulta forman parte del archivo mencionado en el argumento file de read.csv.sql().

Truco: para más info sobre sqldf, puedes ver este vídeo o este resumen con lo básico.

Importar grandes conjuntos de datos en R con la función read.table()

Puedes usar la función “estándar” read.table() para importar tus datos, pero probablemente tarde más que otros paquetes diseñados para datos grandes. Para ver cómo funciona read.table(), vuelve a nuestro primer artículo.

Para acelerarla un poco, puedes ajustarla con argumentos adicionales, así:

df <- read.table("<Path to your file>",
                 header = FALSE,
                 sep="",
                 quote = "",
                 na.strings = "EMPTY",
                 colClasses = c("character", "numeric", "factor"),
                 strip.white = TRUE,
                 comment.char="",
                 stringsAsFactors = FALSE,
                 nrows = n
                 )

Nota:

• primero pasas el archivo (o su ruta), según hayas fijado o no el directorio de trabajo en la carpeta donde está el archivo;
• luego, con header indicas si la primera línea contiene los nombres de las variables. En el ejemplo, no;
• el separador de campos se establece como / con sep; esto significa que los valores de cada línea se separan con ese carácter;
• puedes desactivar o activar el entrecomillado. Aquí, con quote="", lo desactivas;
• defines que la cadena “EMPTY” se interprete como NA;
• defines las clases de tus columnas: primera carácter, segunda numérica y la última factor;
• con strip.white permites eliminar espacios en blanco iniciales y finales en campos de texto no entrecomillados; solo aplica cuando has usado sep;
• con comment.char="" desactivas la interpretación de comentarios;
• no quieres que los caracteres se conviertan en factores; por eso defines colClasses y también estableces stringsAsFactors en FALSE.
  Truco: este argumento, junto con colClasses y comment.char, es de los más importantes para importar sin problemas;
• por último, indicas un máximo de filas a leer.

Truco: si quieres más info sobre todos los argumentos de read.table(), echa un vistazo a nuestro post sobre leer archivos de Excel en R.

Traer grandes conjuntos de datos a R con el paquete readr

Uno de los paquetes más rápidos que puedes usar para importar datos grandes es readr, que permite leer datos tabulares de texto, igual que read.table. No obstante, readr ofrece “funciones de reemplazo con funcionalidad adicional y mucho más rápidas” (ver aquí).

df <- read_table("<Path to your file>",
                 col_names=TRUE)

Nota: el paquete readr también ofrece read_csv(), read_csv2(), read_delim(), read_fwf(), read_tsv() y muchas otras funciones más rápidas que sus equivalentes originales. Detalles aquí.

Truco: más información en esta página de GitHub.

Algunas consideraciones sobre big data en R

Para más consejos sobre cómo manejar big data en R, echa un vistazo a este hilo de StackOverflow, que trata paquetes y también trucos como almacenar datos en formatos binarios y usar saveRDS/readRDS o el paquete rhdf5 para el formato HDF5.

Nota: este último formato ya se ha tratado arriba y existen muchos más paquetes además de los mencionados. Por ejemplo, los usados para conectar con bases de datos, como RODBC y MonetDB.R, también sirven para manejar conjuntos grandes, y el paquete dplyr también demuestra su valor cuando quieres trabajar directamente con datos almacenados en varios tipos de base de datos.

Truco: ¿te interesa manipular datos en R? Entonces nuestro curso interactivo sobre dplyr puede ser para ti. Con la guía de Garrett Grolemund, aprenderás a realizar tareas avanzadas de manipulación de datos con dplyr.

No olvides revisar también este artículo, que prueba el rendimiento de carga de algunos de los paquetes mencionados.

Traer tus datos a R con el paquete rio

Esta “navaja suiza para la entrada/salida de datos” te facilita la vida al importar y exportar datos en R. Puedes leer o escribir datos desde casi cualquier formato: al instalar rio incorporas muchos paquetes de lectura de datos en uno. Luego, para importar o exportar, solo necesitas recordar dos funciones: import() y export(): rio se apoyará en los paquetes subyacentes para inferir la estructura desde la extensión, leer fuentes web de forma nativa y establecer valores por defecto razonables para importación y exportación.

En resumen, rio soporta un amplio conjunto de formatos habituales para importar y exportar.

Importar tus archivos con rio se hace así:

library(rio)
data <- import("<Path to your file>")

Si quieres ver exactamente qué formatos soporta rio, visita esta página.

Para terminar

Si te interesa aprender más sobre big data en R, asegúrate de revisar los cursos How To Work With Quandl in R y “Big Data Analysis With Revolution R Enterprise” en DataCamp.