Quais funções podem ser usadas para importar dados em R?

Passo 1

Você perguntou: “Quais funções podem ser usadas para importar dados em R?” Vou enumerar e explicar, passo a passo, as funções e pacotes mais usados — do mais básico ao mais especializado — com exemplos práticos, dicas do que prestar atenção na prova e como escolher a função certa. Vou assumir que os dados podem estar em arquivos de texto (CSV/TSV), Excel, formatos estatísticos (SPSS/Stata/SAS), JSON/XML, bases de dados ou formatos binários (parquet, HDF5 etc.). Não vou pedir nada mais — só vou te mostrar as opções e como usá-las.

Passo 2

Funções base do R para arquivos de texto (CSV, TSV, tabulares)
  • Principais: read.table(), read.csv(), read.csv2(), read.delim(), read.delim2(), readLines(), scan().
  • Por que usar: estão no R padrão (sem instalar pacotes). Úteis quando não tem tidyverse instalado ou em provas que querem base R.
  • O que cada argumento importante faz (vai aparecer em prova):
    • file: caminho do arquivo (pode ser URL).
    • header: TRUE/FALSE — se a primeira linha tem nomes de colunas.
    • sep: separador (",", ";", "\t").
    • dec: separador decimal ("." ou ",").
    • na.strings: vetor de strings que devem virar NA.
    • colClasses: vetor com classes das colunas (ex.: c("integer","character","numeric")) — acelera leitura e evita parsing errado.
    • encoding: se precisa ajustar codificação (ex.: "UTF-8").
  • Exemplo rápido:
    • dados <- read.csv("dados.csv", header = TRUE, stringsAsFactors = FALSE)
    • dados <- read.table("dados.txt", header = TRUE, sep = "\t", dec = ",")
  • Dica prática para prova: se o enunciado fala em ponto decimal ,, use read.csv2() (que tem sep=";" e dec=",") ou ajuste sep/dec manualmente.

Passo 3

Pacote readr (tidyverse) — funções modernas e rápidas para texto
  • Principais: readr::read_csv(), readr::read_csv2(), readr::read_tsv(), readr::read_delim(), readr::read_fwf(), readr::read_lines().
  • Por que usar: mais rápido que base R, comportamento previsível, retorna tibbles, melhor controle de tipos (col_types) e mensagens de parsing claras.
  • Argumentos importantes:
    • col_types: define tipos das colunas (cols(col1 = col_double(), col2 = col_character())).
    • locale(): para encoding, decimal, agrupador de milhar.
    • na: vetor de strings a considerar como NA.
  • Exemplo:
    • library(readr)
    • dados <- read_csv("dados.csv", locale = locale(encoding = "UTF-8"), na = c("", "NA"))
  • Dica: readr usa mensagens claras quando um valor não cabe no tipo esperado — ótimo para depurar na prova.

Passo 4

data.table::fread — leitura muito rápida para grandes arquivos
  • Função: data.table::fread().
  • Porque usar: detecta automaticamente separadores, header, tipos; é extremamente rápida para arquivos grandes.
  • Exemplo:
    • library(data.table)
    • dt <- fread("dados_grandes.csv")
  • Observação: retorna um data.table (mas funciona como data.frame na maioria dos usos). Em provas, se o enunciado menciona “grande” ou “milhões de linhas”, pense em fread.

Passo 5

vroom — leitura muito rápida (lazy) do tidyverse
  • Função: vroom::vroom().
  • Característica: velocidade e leitura preguiçosa (carrega rápido e lê quando necessário).
  • Exemplo:
    • library(vroom)
    • dados <- vroom("dados.csv")

Passo 6

Excel — ler arquivos .xls/.xlsx
  • Principais pacotes/funções:
    • readxl::read_excel() (levemente mais usado em provas/ambientes): suporta .xls e .xlsx, lê planilhas por índice ou nome (sheet = 1 ou sheet = "Plan1").
    • openxlsx::read.xlsx() — permite mais opções, escrever também.
  • Exemplo:
    • library(readxl)
    • dados <- read_excel("arquivo.xlsx", sheet = 1, col_names = TRUE)
  • Dica: readxl não precisa do Java e geralmente é a escolha padrão em provas.

Passo 7

Formatos de software estatístico (SPSS, Stata, SAS)
  • Pacotes modernos: haven::read_sav() (SPSS), haven::read_dta() (Stata), haven::read_sas() (SAS).
  • Pacote legacy: foreign::read.spss(), foreign::read.dta() — ainda usados, mas haven preserva rótulos e tipos melhor.
  • Exemplo:
    • library(haven)
    • dados_spss <- read_sav("dados.sav")
    • dados_stata <- read_dta("dados.dta")
  • Atenção na prova: haven preserva labels (variáveis etiquetadas) — pode ser importante em questões sobre metadados.

Passo 8

JSON, XML, YAML — dados semi-estruturados
  • JSON: jsonlite::fromJSON() para transformar JSON em list ou data.frame.
    • library(jsonlite)
    • obj <- fromJSON("dados.json")
  • XML: xml2::read_xml() e XML::xmlParse() seguido de extração com XPath.
    • library(xml2)
    • doc <- read_xml("dados.xml")
  • YAML: yaml::read_yaml("dados.yaml").
  • Dica: APIs retornam JSON — na prova, combine httr::GET() + content() ou jsonlite::fromJSON().

Passo 9

APIs e web — buscar dados pela internet
  • Padrão simples: read.csv("http://site/dados.csv") ou readr::read_csv("http://...").
  • Para APIs (requisições HTTP): httr::GET() + content() ou httr::GET() + jsonlite::fromJSON(content(..., "text")).
  • Exemplo:
    • library(httr); library(jsonlite)
    • res <- GET("https://api.exemplo.com/dados")
    • txt <- content(res, "text", encoding = "UTF-8")
    • dados <- fromJSON(txt)
  • Dica: em provas, lembre-se de tratar autenticação (tokens) se mencionado.

Passo 10

Base de dados relacionais (SQL)
  • Pacotes e fluxo padrão: DBI + driver (ex.: RSQLite, RPostgres, RMariaDB, odbc).
  • Esquema:
    • library(DBI)
    • con <- dbConnect(RSQLite::SQLite(), "minha_base.db")
    • dados <- dbGetQuery(con, "SELECT * FROM tabela WHERE condicao")
    • dbDisconnect(con)
  • Dica: provas pedem usar dbGetQuery() para importar resultados de uma consulta SQL.

Passo 11

Formatos colunares/binary: Parquet, Feather, Arrow
  • arrow::read_parquet("dados.parquet"), arrow::read_feather("dados.feather").
  • Vantagem: muito eficientes para big data; preservam tipos e são intercambiáveis entre linguagens.
  • Exemplo:
    • library(arrow)
    • df <- read_parquet("dados.parquet")

Passo 12

HDF5, netCDF e outros formatos científicos
  • HDF5: rhdf5::h5read() (Bioconductor).
  • netCDF: ncdf4::nc_open() e ncdf4::ncvar_get().
  • Use quando a prova mencionar dados científicos/grandes arrays.

Passo 13

Wrapper universal: rio::import
  • rio::import("arquivo.xxx") detecta formato por extensão e chama a função adequada (CSV, Excel, SPSS, Stata, JSON, etc.).
  • Exemplo:
    • library(rio)
    • dados <- import("arquivo.xlsx")
  • Bom em provas quando querem uma solução simples e genérica.

Passo 14

Outras funções úteis de baixo nível
  • readBin() para leitura binária específica.
  • gzfile(), bzfile() e unz() para abrir arquivos compactados/arquivos em zip: read.csv(gzfile("dados.csv.gz")).
  • feather::read_feather() se usar pacote feather antigo.

Passo 15

Principais argumentos que você precisa dominar na prova (resuma-se a decorar)
  • file (caminho/URL), header, sep, dec, na.strings, colClasses / col_types, encoding, sheet (Excel).
  • Saber definir colClasses/col_types evita erros e aumenta velocidade.
  • Sempre confira com str(dados) ou glimpse(dados) para ver se as colunas vieram nos tipos esperados.

Passo 16

Como escolher na hora da prova (resumo rápido e prático)
  • Arquivo CSV/TSV pequeno ou prova básica: read.csv() / read.table() (base R) ou readr::read_csv() (mais elegante).
  • Arquivo CSV/TSV grande: data.table::fread() ou vroom::vroom().
  • Excel: readxl::read_excel().
  • SPSS/Stata/SAS: haven::read_sav(), haven::read_dta(), haven::read_sas().
  • JSON/XML/API: jsonlite::fromJSON() / xml2::read_xml() / httr::GET() + content().
  • Banco de dados: DBI::dbConnect() + dbGetQuery().
  • Formatos colunares/Big Data: arrow::read_parquet() ou vroom/fread.
  • Se precisar de solução única e rápida: rio::import().

Passo 17

Problemas comuns e como consertar (o que pode aparecer na correção da prova)
  • Vírgula vs ponto decimal: ajustar dec ou usar read.csv2().
  • Codificação estranha (acentos): colocar encoding = "UTF-8" ou usar fileEncoding em base R.
  • Datas lidas como texto: usar lubridate::ymd() / as.Date() com format.
  • Strings viram fatores: em versões antigas do R, stringsAsFactors = TRUE por padrão; use stringsAsFactors = FALSE ou readr que não converte automaticamente.
  • NA sendo lido como texto: ajuste na.strings / na no readr.
  • Erros de parsing: especifique colClasses/col_types para forçar o tipo correto.

Passo 18

Checklist rápido para a prova (faça mentalmente antes de escolher a função)
  • Tipo do arquivo? (.csv, .xlsx, .sav, .json, .parquet, banco de dados)
  • Tamanho do arquivo? (pequeno → base/readr; grande → fread/vroom/arrow)
  • Precisa de metadados (labels)? (SPSS/Stata → use haven)
  • Precisa de autenticação/URL/API? (use httr + jsonlite)
  • Precisa preservar codificação/acentos? (defina encoding/locale)
  • Quer uma solução única e automática? (use rio::import)

Resposta

read.table
read.csv
read.csv2
read.delim
read.delim2
readLines
scan
readr::read_csv
readr::read_csv2
readr::read_tsv
readr::read_delim
data.table::fread
vroom::vroom
readxl::read_excel
openxlsx::read.xlsx
haven::read_sav
haven::read_dta
haven::read_sas
foreign::read.spss
jsonlite::fromJSON
xml2::read_xml
yaml::read_yaml
httr::GET + content() (para APIs)
DBI::dbConnect / DBI::dbGetQuery (com RSQLite/RPostgres/odbc etc.)
arrow::read_parquet / arrow::read_feather
rhdf5::h5read (HDF5)
ncdf4::nc_open (netCDF)
rio::import
feather::read_feather

Exercícios relacionados