Importando dados no R - parte dois

Neste tutorial de continuidade de This R Data Import Tutorial Is Everything You Need-Part One, a DataCamp segue com um guia completo e prático para importar dados no R rapidamente, indo de arquivos texto simples a formatos mais avançados como SPSS e SAS.

Como muitos leitores notaram no primeiro post, alguns ótimos pacotes para importar dados no R ainda não tinham sido abordados, e também não ficou clara a distinção entre trabalhar com conjuntos de dados padrão e conjuntos de dados grandes. Por isso, esse será o foco do post de hoje.

Siga a leitura para descobrir outras formas de importar seu arquivo específico no R e, se tiver dúvidas adicionais ou encontrar algum erro que devamos corrigir, fique à vontade para falar com a gente.

(Experimente este curso interativo: Importing Data in R (Part 1) para trabalhar com arquivos CSV e Excel no R.)

Colocando dados de fontes comuns no R

Primeiro, vamos nos aprofundar nas maneiras de trazer para o R dados de fontes comuns, geralmente em formato de planilha. Assim como no post anterior, o foco será em leitura de dados diferente de Excel ou outros tipos de arquivos.

Em seguida, falaremos de dados vindos de outros lugares, como softwares estatísticos, bancos de dados, web scraping, etc.

Se você quer saber mais sobre os passos prévios à importação, confira o nosso primeiro post, que explica como preparar seus dados e seu ambiente antes de trazê-los para o R.

Lendo arquivos texto simples no R com scan()

Além da read.table(), mencionada no primeiro post do tutorial, a função scan() também ajuda a lidar com dados armazenados em arquivos texto delimitados simples. Diferente de read.table(), a scan() retorna uma lista ou um vetor, e não um data frame.

Suponha que você tenha o seguinte arquivo .txt:

24 1991
21 1993
53 1962

Você pode ler os dados (disponível para download aqui) com o comando:

data <- scan("birth.txt")

Observação: seu arquivo também pode estar online. Nesse caso, basta passar a URL como primeiro argumento da função scan().

Alternativamente, você pode ler os dados em uma matriz:

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

Dica: para fazer isso de forma mais precisa, talvez você precise informar argumentos adicionais para deixar a matriz do jeito que precisa. Veja esta página para mais informações sobre a função matrix().

Você também pode ler as colunas do arquivo de entrada em vetores separados:

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

Note como primeiro você passa o arquivo (ou caminho) com sua extensão como argumento (dependendo se você definiu o diretório de trabalho para a pasta do dataset ou não) e depois especifica o tipo dos dados a serem lidos, se deseja pular a primeira linha do dataset, qual caractere delimita os campos e se quer imprimir uma linha informando quantos itens foram lidos.

Se seus dados tiverem tipos diferentes, ajuste a função scan(), como neste exemplo:

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

Dica: você pode testar! Baixe o arquivo usado acima aqui.

Depois, também dá para ler os dados em um data frame:

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

Dica: muitos dos argumentos que scan() aceita são os mesmos de read.table(). Vale sempre consultar a documentação! Veja aqui os argumentos de scan().

Lembre-se de que você pode obter e definir o diretório de trabalho com os seguintes comandos, respectivamente:

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

Lendo dados de colunas de largura fixa no R com read.fwf()

Para ler uma tabela em formato de largura fixa em um data frame no R, use a função read.fwf() do pacote utils.

Você usa essa função quando seu arquivo tem colunas com espaços ou colunas sem separadores entre elas.

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

Aqui você sabe, por exemplo, que o valor da disciplina está sempre nos 7 primeiros caracteres de cada linha, que o sexo sempre está na posição 22, e que as notas vão do caractere 25 ao 30.

Se quiser testar a carga desses dados no R, baixe o arquivo texto aqui.

Execute o seguinte comando para ler corretamente os dados acima no 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)

Observação: o argumento widths informa as larguras dos campos. Neste caso, os sete primeiros caracteres ficam para o nome do curso; Em seguida, você não quer ler os 14 caracteres seguintes: passe -14. Depois, precisa de um caractere para o sexo, mas quer descartar os dois seguintes, então passe -2. Todos os caracteres restantes devem ser lidos em colunas separadas, então você os divide passando 1,1,1,1,1,1. Esses valores variam conforme as colunas que você precisa importar.

Há vários argumentos extras que você pode passar para read.fwf(). Clique aqui para saber mais.

Observação: se quiser carregar um arquivo usando especificações de formato ao estilo Fortran, use a função read.fortran():

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

Como você vê no exemplo acima, você usa especificações de formato Fortran como segundo argumento da função read.fortran(). Os argumentos seguem o estilo: “rFl.d”, “rDl.d”, “rXl”, “rAl” ou “rIl”, onde “l” é o número de colunas, “d” é o número de casas decimais e “r” é o número de repetições. Aqui aparecem 2.1, 2.0 e 2 via c(), o que significa três colunas com duas linhas. Na primeira coluna, valores com uma casa decimal; na segunda e na terceira, sem casas decimais.

Quanto aos tipos de valores das colunas, você tem:

• “F” e “D” para formatos numéricos;
• “A” para caracteres;
• “I” para inteiros;
• E “X” para indicar colunas que podem ser ignoradas.

Neste caso, a primeira e a segunda colunas têm formatos numéricos, enquanto a terceira é inteira.

Observação: os códigos de repetição “r” e de casas decimais “d” são opcionais. O comprimento “l” é obrigatório, exceto para formatos “X” quando “r” está presente.

Levando suas planilhas (Google) para o R

Planilhas podem ser importadas no R de várias formas, como você já deve ter visto no nosso tutorial sobre como ler e importar arquivos do Excel no R ou no primeiro post This R Data Import Tutorial Is Everything You Need. Esta seção amplia esse tema e vai além, incluindo planilhas do Google e arquivos DIF!

Role a página para saber mais sobre como importar suas planilhas no R.

Importando planilhas do Excel no R

Além do pacote xlsx, há várias outras opções para ler planilhas no R:

1. Lendo planilhas do Excel no R a partir da área de transferência

Se você tem uma planilha aberta, pode copiar o conteúdo para a área de transferência e importar rapidamente no R. Para isso, use as funções readClipboard() ou read.table():

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

Como você verá ao testar, a primeira abordagem funciona bem para vetores, mas complica quando há dados tabulares na área de transferência. Se quiser saber mais sobre read.table(), volte à primeira parte do tutorial ou ao nosso guia sobre leitura e importação de arquivos Excel no R.

2. Lendo planilhas do Excel no R via pacote RODBC

A segunda forma é por meio do pacote RODBC:

• Uma primeira maneira de usar esse pacote é assim:

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

Observação: o argumento que você passa para odbcConnect() é um DSN. Para um guia completo de como configurar o DSN e a conexão, veja esta página, um tutorial extenso e acessível!

• Depois de configurar a conexão, você pode usar a função sqlQuery() para buscar dados de planilhas .xls:

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

Super dica: acesse esta página, um tutorial extenso e acessível!

Ao final da sessão do R, não esqueça de fechar as conexões:

odbcCloseAll()

Dica: para saber mais sobre importação de planilhas ou arquivos Excel no R, volte ao nosso primeiro tutorial sobre importação de dados no R ou leia nosso guia sobre leitura e importação de arquivos Excel no R, que aborda os pacotes readxl e XLConnect, entre outros.

Importando planilhas do Google no R

O pacote googlesheets com a função gs_read() permite ler planilhas do Google no R.

Comece executando:

gs_ls()

Deixe o navegador abrir e conclua a autenticação. Depois, para ler ou editar os dados, você precisa registrá-los. Faça isso especificando a planilha pelo título ou pela chave:

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

Em seguida, leia os dados:

gs_read(data)

Este é apenas um panorama do que fazer com googlesheets. Leia todos os detalhes aqui e confira também esta página.

Lendo arquivos DIF (Data Interchange Format) no R

Use a função read.DIF() para importar arquivos DIF no R:

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

Observação: você pode indicar se sua planilha tem cabeçalho e se quer importar os dados “como estão”, ou seja, se deseja converter variáveis de texto em fatores. Aqui, você não quis essa conversão e passou !stringsAsFactors.

Para mais informações sobre a função e seus argumentos, acesse esta página.

Importando arquivos do Excel no R

Além de planilhas, você pode querer trazer os próprios arquivos Excel para o R. Continue a leitura para ver como fazer isso!

Observação: este post aprofunda o conteúdo do nosso tutorial sobre leitura e importação de arquivos Excel no R e do primeiro post This R Data Import Tutorial Is Everything You Need!

Importando arquivos Excel no R com readxl

Embora o pacote ainda esteja em desenvolvimento ativo, vale muito a pena conferir, pois oferece uma forma bem simples de ler arquivos Excel:

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

Lembre-se: você pode apenas digitar o nome do arquivo com a extensão se ele estiver no seu diretório de trabalho. Obtenha e defina o diretório com:

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

Observação: é possível especificar a aba a ler, nomes e tipos de colunas, valores ausentes e o número de linhas a pular antes da leitura, com os argumentos sheet, col_names, col_types, na e skip, respectivamente. Saiba mais aqui.

Lendo arquivos Excel no R com openxlsx

O pacote openxlsx também oferece uma forma simples de ler arquivos .xlsx no R:

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

Para mais detalhes sobre o pacote ou os argumentos de read.xlsx(), clique aqui.

Dica: para saber mais sobre a importação de arquivos Excel no R, volte ao nosso primeiro tutorial sobre “importação de dados no R” ou leia o nosso guia completo sobre leitura e importação de arquivos Excel no R, que também cobre o pacote XLConnect, entre outros.

Importando planilhas OpenDocument no R

Use a função read.ods() do pacote readODS para ler planilhas OpenDocument no R e colocá-las em data frames:

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

Observação: além do arquivo a importar, você pode indicar a aba desejada e escolher exibir fórmulas como fórmulas (por exemplo, “SUM(B1:B3)”) ou como valores resultantes.

Importando arquivos JSON (JavaScript Object Notation) no R

No nosso primeiro post sobre importação de dados no R, citamos o pacote rjson para ler arquivos JSON.

Mas há outros pacotes que você pode usar para importar JSON no R. Continue lendo para saber mais!

Importando JSON no R com o pacote jsonlite

Recentemente entre os 25 mais baixados de R packages, com 66.952 downloads, o pacote jsonlite é um dos queridinhos dos usuários de R.

Você importa JSON com a função fromJSON():

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

Para um guia rápido e bem explicado de jsonlite, acesse aqui.

Importando JSON no R com o pacote RJSONIO

O terceiro pacote conhecido para JSON no R é o RJSONIO. Assim como nos pacotes jsonlite e jsonlite, você usa fromJSON():

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

Qual é o melhor pacote para JSON?

Há muita discussão sobre isso. Para saber mais, confira:

• esta página traz exemplos de código que ajudam a entender comportamento e performance de pacotes de JSON no R.
• Leia também este post, que busca identificar qual pacote lida melhor com JSON no R.

Importando dados de softwares estatísticos no R

Se seus dados não são exatamente “formato planilha” e não estão em Excel ou JSON, talvez sejam de algum software estatístico.

Esta seção mostra mais formas de ler arquivos SPSS, Stata e SAS, além de um panorama sobre S-plus e Epi Info. Volte ao nosso primeiro post ou aos links abaixo para mais informações!

Importando arquivos SPSS no R

Em vez de usar o pacote foreign, você também pode recorrer ao pacote haven para trazer arquivos SPSS para o R.

Lembre-se de instalar e carregar o pacote antes de começar!

O haven oferece a função read_spss() para ler arquivos SPSS no R:

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

Importando arquivos Stata no R

Assim como o pacote foreign, o haven também traz uma função para ler arquivos Stata no R, a read_dta():

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

Lembre-se de instalar os pacotes quando necessário e carregá-los no ambiente. Por exemplo, para instalar e carregar o haven:

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

Importando arquivos SAS no R

Como o pacote sas7bdat foi citado no último post, aqui vamos focar em outras maneiras de ler SAS:

1. Como importar arquivos SAS XPORT no R com o pacote foreign

O pacote foreign com a função read.xport() também permite importar arquivos SAS XPORT:

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

2. Como importar arquivos SAS XPORT no R com o pacote SASxport

O pacote sasXPORT também lê arquivos SAS XPORT pela função read.xport():

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

3. Como importar arquivos SAS no R com o pacote haven

Assim como os pacotes foreign e sas7bdat, o haven também lê arquivos b7dat no R com a função read_sas():

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

Importando arquivos S-plus no R

Para datasets antigos de S-plus, produzidos no Windows versões 3.x, 4.x ou 2000, ou Unix 3.x com inteiros de 4 bytes, use a função read.S() do pacote foreign:

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

Lendo arquivos Epi Info no R

Como vimos no tutorial anterior (e neste), o pacote foreign oferece várias funções para ler formatos específicos no R, incluindo Epi Info. Use read.epiinfo() para importar:

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

Para mais informações sobre Epi Info, clique aqui.

Importando dados de outras fontes no R

Além das fontes comuns e dos softwares estatísticos, há muitas outras origens de dados para ler no R.

Veja algumas abaixo. Continue a leitura!

Importando arquivos MATLAB no R

Use o pacote R.matlab com a função readMat() para importar arquivos do MATLAB no R.

Você pode passar uma string como primeiro argumento (interpretada como nome do arquivo) ou um vetor bruto (conexão binária):

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

A função readMat() retorna uma lista nomeada com todas as variáveis do arquivo MAT importado.

Lendo arquivos Octave no R

O pacote foreign aparece de novo! Use read.octave() para importar dados texto do Octave no R:

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

Importando dados do FitbitScraper no R

Você pode usar o pacote fitbitScraper para obter dados do fitbit.

(Para quem não conhece: a empresa oferece dispositivos como rastreadores de atividade e outros gadgets que medem dados pessoais, como número de passos e qualidade do sono.)

Veja aqui um tutorial prático e curto de como usar o pacote fitbitScraper.

Importando dados do Quantmod no R

Você pode usar este pacote para extrair dados financeiros de fontes na Internet com R. A função para trazer dados é getSymbols(), como no exemplo:

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

Observação: primeiro você informa um vetor de caracteres com os símbolos a carregar. Aqui, "YHOO". Depois define a fonte. As opções disponíveis hoje incluem yahoo, google, MySQL, FRED, csv, RData e oanda.

Em seguida, defina os parâmetros de lookup e salve para sessões futuras:

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

Em novas sessões, chame

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

Para mais informações sobre aplicações de finanças quantitativas no R, clique aqui ou acesse esta página para um tutorial detalhado para iniciantes no quantmod.

Importando arquivos ARFF no R

Dados em formato Attribute-Relation File Format (ARFF) do Weka podem ser lidos com a função read.arff():

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

Para mais informações, visite esta página.

Observação: o pacote RWeka também oferece a mesma função para importar ARFF. Saiba mais aqui!

Importando dados de bancos de dados no R

Além de MonetDB.R, rmongodb e RMySQL, cobertos no post anterior, você tem outros pacotes para conectar bancos de dados no R.

você também tem mongolite, RMongo, RODBC, ROracle, RPostgreSQL, RSQLite, RJDBC.

Para tutoriais sobre esses pacotes, confira:

• Para começar com mongolite, este tutorial pode ajudar;
• Para ajuda com RMongo, veja este post;
• O pacote RODBC é amplamente discutido também neste tutorial. Para uma descrição mais curta do método, vá aqui;
• Para aprender a usar ROracle, confira esta apresentação;
• Para saber mais sobre RPostgreSQL, vá aqui ou aqui;
• Vá neste tutorial se quiser saber mais sobre RSQLite;
• Por fim, para conectar ao SQL Server com RJDBC, veja este post ou acesse esta página para conectar a um banco Oracle. Observação: esta última página também traz outras opções para Oracle.

Observação: existe também o pacote de interface de bancos de dados DBI, que permite a comunicação entre o R e sistemas gerenciadores de bancos relacionais. Para mais informações, clique aqui.

Algumas explicações sobre como trabalhar com esse pacote podem ser encontradas aqui.

Importando arquivos binários no R

Arquivos binários armazenam informações em grupos de dígitos binários (0 e 1). Oito dígitos binários formam um byte. Você pode ler dados binários com a função 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 um exemplo mais detalhado, veja esta página. Para mais informações sobre readBin(), clique aqui.

Lendo formatos binários no R

Os pacotes hdf5, h5r, rhdf5, RNetCDF, ncdf e ncdf4 oferecem interfaces para os arquivos HDF5 da NASA e netCDF da UCAR.

Se você quer tutoriais sobre HDF5 ou netCDF no R, veja:

• Um excelente tutorial sobre HDF no R, também com o pacote pathfinder, está aqui;
• Um tutorial introdutório e acessível sobre netCDF no R está nesta página.

Importando arquivos DBF no R

DBF (DataBase File) é o formato base do dBase. Você pode ler arquivos DBF com o pacote foreign, via função read.dbf():

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

Observação: no Windows, você também pode usar o pacote RODBC com a função odbcConnectDbase() para ler DBF via driver ODBC do dBase da Microsoft.

Importando tabelas de contingência “flat” no R

O pacote foreign permite ler múltiplos formatos; tabelas de contingência “flat” não são exceção. Use a função read.ftable() para isso:

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

Lembre-se de que tabelas de contingência “flat” são semelhantes às “normais”: elas contêm as contagens de cada combinação dos níveis das variáveis (fatores) envolvidas. A diferença é que a informação é rearranjada como uma matriz cujas linhas e colunas correspondem às combinações únicas dos níveis das variáveis de linha e coluna. Por isso, as tabelas “flat” são preferidas para representar tabelas de contingência de alta dimensão.

Lendo arquivos de SIG (GIS) no R

Você pode usar os pacotes rgdal e raster, entre outros, para importar arquivos GIS no R.

Se não sabe por onde começar com rgdal, confira este ótimo post, que introduz o trabalho com dados geoespaciais no R.

Você também pode ver este tutorial, que usa rgdal e raster.

Importando tabelas do ITIS (Integrated Taxonomical Information) no R

Você pode importar tabelas do ITIS com a função read.table():

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

Para mais informações sobre o ITIS, clique aqui.

Importando conjuntos de dados grandes no R

A importação de conjuntos de dados grandes costuma gerar debate entre usuários de R. Além dos pacotes para conexão com bancos, há outros que se destacam ao lidar com big data.

Importando grandes volumes de dados no R com o pacote data.table

Conhecido como “fast and friendly file finagler”, o popular pacote data.table é extremamente útil e fácil de usar. Sua função fread() importa dados de arquivos delimitados regulares direto no R, sem rodeios.

Observação: “regular” aqui significa que todas as linhas têm o mesmo número de colunas. Exemplo:

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

Um dos pontos fortes é que controles como sep, colClasses e nrows são detectados automaticamente. Tipos bit64::integer64 também são identificados e lidos diretamente, sem precisar ler como texto para depois converter.

Lembre-se: tipos bit64::integer64 são inteiros de 64 bits. Por padrão, inteiros são 32 bits. Como o tipo é detectado, o sistema já sabe que é número e não precisa ler como caractere para converter.

Exemplo de fread():

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

Observação: ler com fread() retorna um 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>

Isso difere de read.table(), que cria um data frame.

Você encontra mais diferenças entre data frames e data.tables aqui. Em resumo: todo data.table também é um data.frame. Um data.table pode ser passado para qualquer pacote que aceite data.frame e esse pacote pode usar a sintaxe [.data.frame no data.table. Leia mais aqui.

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
              )

Observação: a entrada também pode ser um arquivo local, não precisa ser uma URL. E note como muitos argumentos são iguais aos de read.table(), por exemplo.

Dica: quer saber mais sobre data.table? Nosso curso Data Analysis In R, The data.table Way pode te interessar! Com a orientação de Matt Dowle e Arun Srinivasan, você vai do básico ao avançado em pouco tempo.

Importando grandes volumes de dados no R com o pacote ff

O pacote ff oferece “armazenamento eficiente em disco para dados grandes e funções de acesso rápido”. Ele aparece com frequência em discussões sobre leitura de big data como data frames, como aqui.

Para importar arquivos texto separados em ff data frames, use read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() ou read.delim2.ffdf(), de forma semelhante à read.table() e suas variações, descritas em um post anterior:

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

Observação: o primeiro argumento pode ser NULL (como aqui) ou um objeto ffdf opcional ao qual os registros lidos serão anexados. Para saber mais, veja aqui. Depois, informe o arquivo com o argumento file. Você também pode limitar o número máximo de linhas com nrows (assim como em read.table()!).

Você pode ir além e especificar codificação do arquivo, níveis ou o nome de uma função chamada para ler cada bloco:

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

Dica: mais argumentos para read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() ou read.delim2.ffdf() estão aqui.

Importando grandes volumes de dados no R com bigmemory

Outro pacote que aparece bastante em buscas sobre grandes volumes de dados no R é o bigmemory. Ele permite “gerenciar matrizes massivas com memória compartilhada e arquivos mapeados em memória”.

Observação: você não pode usar este pacote no Windows: não há binários para Windows.

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

Como de praxe, você informa o nome do arquivo e depois define separador, cabeçalho e número de linhas a pular antes da leitura com os argumentos sep, header e skip, respectivamente.

Observação: estes são só alguns exemplos! Há muitos outros argumentos em read.big.matrix()! Consulte a documentação para saber mais.

Lendo grandes volumes de dados no R com o pacote sqldf

O pacote sqldf também é uma opção quando você trabalha com dados grandes. Ele permite “executar selects SQL no R”, e a função read.csv.sql() é especialmente útil quando você quer ler um arquivo aplicando um filtro SQL. Assim, apenas parte dos dados é processada pelo R:

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

Observação: o exemplo acima é semelhante a outras funções para importar dados grandes, com a diferença de que o segundo argumento passado para read.csv.sql() é uma instrução SQL. As tabelas às quais você se refere na query fazem parte do arquivo informado no argumento file de read.csv.sql().

Dica: para mais informações sobre o uso de sqldf, veja um vídeo tutorial aqui ou um resumo escrito aqui.

Importando grandes volumes de dados no R com a função read.table()

Você pode usar a função “padrão” read.table() para importar seus dados, mas ela provavelmente será mais lenta do que pacotes feitos para big data. Para ver o funcionamento de read.table(), volte ao nosso primeiro post.

Para ganhar velocidade, você pode “tuná-la” adicionando argumentos à função, assim:

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
                 )

Observação:

• primeiro você passa o arquivo (ou caminho), dependendo do seu diretório de trabalho;
• depois, usa header para indicar se a primeira linha contém os nomes das variáveis. No exemplo, não;
• o separador é definido como / com sep; isso quer dizer que os valores em cada linha são separados por esse caractere;
• em seguida, você pode desabilitar/abilitar aspas. Aqui, quote="" desabilita;
• você define que a string “EMPTY” deve ser interpretada como NA;
• também define as classes das colunas: a primeira é caractere, a segunda numérica e a última fator;
• com strip.white você remove espaços em branco iniciais/finais de campos de caractere não citados; só se aplica quando sep é usado!
• com comment.char="" você desliga a interpretação de comentários;
• você não quer converter caracteres em fatores! Por isso definiu colClasses e confirmou com stringsAsFactors=FALSE.
  Dica: este argumento, junto com colClasses e comment.char, é dos mais importantes para uma importação suave!
• por fim, limite de linhas a ler.

Dica: para mais detalhes sobre todos os argumentos de read.table(), leia nosso post sobre leitura de arquivos Excel no R.

Importando grandes volumes de dados no R com o pacote readr

Uma das opções mais rápidas para importar dados grandes no R é o pacote readr, que lê dados tabulares de texto, assim como read.table. Porém, o readr traz “funções de substituição que oferecem funcionalidades adicionais e são muito mais rápidas” (veja aqui).

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

Observação: o readr também oferece read_csv(), read_csv2(), read_delim(), read_fwf(), read_tsv() e outras funções mais rápidas do que as originais! Detalhes aqui.

Dica: mais informações neste repositório no GitHub.

Algumas observações sobre big data no R

Para mais dicas sobre big data no R, vale ver esta discussão no StackOverflow, que fala de pacotes e também de boas práticas como armazenar dados em formatos binários e usar saveRDS/readRDS ou o pacote rhdf5 para o formato HDF5.

Observação: esse último formato foi citado acima e há muitos outros pacotes além dos que cobrimos. Por exemplo, pacotes de conexão com bancos, como RODBC e MonetDB.R, também ajudam a lidar com dados maiores; e o pacote dplyr é muito útil quando você quer trabalhar diretamente com dados armazenados em diferentes bancos.

Dica: interessado em manipulação de dados no R? Então nosso curso interativo de dplyr pode ser para você! Com a orientação de Garrett Grolemund, você vai aprender a realizar tarefas avançadas de manipulação com dplyr.

Confira também este post, que testa a performance de carga de alguns dos pacotes listados!

Importando seus dados no R com o pacote rio

Este “canivete suíço para Entrada/Saída de dados” facilita a vida na hora de importar e exportar dados no R! Você pode ler e gravar dados de quase qualquer formato: ao instalar o pacote rio, você reúne vários pacotes de leitura em um só. Para importar ou exportar, basta lembrar duas funções: import() e export(). O rio usa os pacotes específicos para inferir a estrutura pelo tipo de arquivo, ler fontes web nativamente e definir padrões razoáveis de importação/exportação.

Em resumo, o rio suporta um conjunto amplo de formatos populares, tanto para import quanto para export.

A importação com o rio acontece assim:

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

Para ver exatamente quais formatos o rio suporta, visite esta página.

Para fechar

Se você quer aprender mais sobre como trabalhar com big data no R, confira os cursos How To Work With Quandl in R e “Big Data Analysis With Revolution R Enterprise” na DataCamp!