Aula 3 – Importação e Exportação de Dados

Objetivo da Aula

Compreender como importar e exportar dados no R, trabalhando com arquivos de texto, arquivos .csv, arquivos .csv2, objetos .RData, arquivos .rds e, de forma introdutória, planilhas do Excel.

1. Introdução

Nas aulas anteriores, estudamos objetos, vetores, matrizes, dataframes e listas. Agora vamos aprender como trazer dados externos para dentro do R e como salvar resultados produzidos durante uma análise.

Comentário do professor

Uma análise de dados raramente começa com os dados digitados manualmente no R. Na prática, os dados costumam estar em arquivos externos, como .txt, .csv, .xlsx ou arquivos próprios do R.

2. Diretório de trabalho

Antes de importar ou exportar arquivos, precisamos saber em qual pasta o R está trabalhando.

Execute este código

getwd()

[1] "/Users/marcelocarlosribeiro/Documents/2026.1/EST 128/Aulas/Aula 3 "

Comentário do professor

A função getwd() mostra o diretório de trabalho atual. É nessa pasta que o R vai procurar arquivos quando não informamos o caminho completo.

Também podemos listar os arquivos disponíveis no diretório atual.

Execute este código

list.files()

 [1] "alfafa.txt"               "aula3_files"             
 [3] "aula3.html"               "aula3.qmd"               
 [5] "aula3.rmarkdown"          "clientes.csv"            
 [7] "dados_aula3.RData"        "dados_brasil.csv"        
 [9] "estilo.css"               "notas.RData"             
[11] "notas.rds"                "notas.txt"               
[13] "producao.csv"             "resultado_csv2.csv"      
[15] "resultado_write_csv.csv"  "resultado_write_csv2.csv"
[17] "resultado.csv"            "resultado.rds"           
[19] "resultado.txt"            "resultado.xlsx"          
[21] "rsconnect"               

2.1 Alterando o diretório de trabalho

Atenção

O caminho do diretório varia de computador para computador. Por isso, o exemplo abaixo está comentado.

# setwd("C:/meus_dados")

Comentário do professor

No R, usamos / no caminho das pastas. Mesmo no Windows, evite escrever caminhos com \.

3. Preparação dos dados

Antes de importar dados, é importante verificar como o arquivo está organizado.

Boas práticas na preparação dos dados

Ao preparar uma base para ser lida no R:

• Evite nomes de colunas com espaços.
• Evite acentos e caracteres especiais.
• Use nomes curtos e informativos.
• Prefira nomes em letras minúsculas.
• Use _ para separar palavras.
• Evite colocar textos explicativos no meio da tabela.

Comentário do professor

O R vai interpretar o arquivo exatamente como ele está escrito. Quanto mais organizada estiver a base, menor será a chance de erro na importação.

4. Criando arquivos de exemplo

Para que esta aula funcione em qualquer computador, vamos criar alguns arquivos temporários. Depois vamos importar esses arquivos de volta para o R.

4.1 Criando um dataframe

Execute este código

alfafa <- data.frame(
  trat = c("A", "A", "A", "B", "B", "B", "C", "C", "C"),
  bloco = c("I", "II", "III", "I", "II", "III", "I", "II", "III"),
  prod = c(2.89, 2.88, 1.88, 1.58, 1.28, 1.22, 2.29, 2.98, 1.55)
)

alfafa

4.2 Salvando um arquivo .txt de exemplo

Execute este código

write.table(
  x = alfafa,
  file = "alfafa.txt",
  sep = " ",
  quote = FALSE,
  row.names = FALSE
)

list.files()

 [1] "alfafa.txt"               "aula3_files"             
 [3] "aula3.html"               "aula3.qmd"               
 [5] "aula3.rmarkdown"          "clientes.csv"            
 [7] "dados_aula3.RData"        "dados_brasil.csv"        
 [9] "estilo.css"               "notas.RData"             
[11] "notas.rds"                "notas.txt"               
[13] "producao.csv"             "resultado_csv2.csv"      
[15] "resultado_write_csv.csv"  "resultado_write_csv2.csv"
[17] "resultado.csv"            "resultado.rds"           
[19] "resultado.txt"            "resultado.xlsx"          
[21] "rsconnect"               

Comentário do professor

A função write.table() é usada para exportar objetos do R, como dataframes ou matrizes, para arquivos de texto.

Neste exemplo:

• x = alfafa: indica qual objeto será exportado. Aqui estamos exportando o dataframe alfafa.
• file = "alfafa.txt": define o nome do arquivo que será criado.
• sep = " ": define o separador entre as colunas. Neste caso, usamos espaço.
• quote = FALSE: evita que textos sejam salvos entre aspas.
• row.names = FALSE: evita salvar a numeração das linhas como uma coluna extra.

Não é necessário instalar nenhum pacote para usar write.table(), pois essa função pertence ao R base.

4.3 Criando um arquivo .csv de exemplo

Execute este código

producao <- data.frame(
  x = 1:10,
  y = c(6.7, 7.9, 9.1, 6.6, 7.5, 8.8, 7.7, 7.6, 6.5, 7.9)
)

write.table(
  x = producao,
  file = "producao.csv",
  sep = ";",
  dec = ".",
  quote = FALSE,
  row.names = FALSE
)

producao

Comentário do professor

Neste exemplo, alguns argumentos já foram usados anteriormente, como x, file, sep, quote e row.names.

O novo argumento importante aqui é:

• dec = ".": define qual símbolo será usado como separador decimal no arquivo exportado. Neste caso, os números serão salvos com ponto decimal, como 6.7, 7.9 e 9.1.

Além disso:

• sep = ";": indica que as colunas serão separadas por ponto e vírgula. Esse formato é muito comum em arquivos .csv usados no Brasil.
• file = "producao.csv": cria um arquivo chamado producao.csv no diretório de trabalho.
• producao: ao final do código, apenas imprime o dataframe no documento para visualizarmos os dados criados.

5. Importando dados com read.table()

A função read.table() é uma das funções mais gerais para importar dados em formato de texto.

Argumentos importantes

Alguns argumentos muito usados em read.table() são:

• file: nome ou caminho do arquivo.
• header: indica se a primeira linha contém os nomes das colunas.
• sep: indica o separador das colunas.
• dec: indica o separador decimal.

5.1 Importando arquivo .txt

Execute este código

dados_alfafa <- read.table(
  file = "alfafa.txt",
  header = TRUE
)

dados_alfafa

Comentário do professor

Como o arquivo alfafa.txt está no diretório de trabalho, não precisamos informar o caminho completo.

5.2 Importando arquivo .csv com separador ;

Execute este código

dados_producao <- read.table(
  file = "producao.csv",
  header = TRUE,
  sep = ";",
  dec = "."
)

dados_producao

Atenção

Se o arquivo usa ; para separar colunas, precisamos informar sep = ";". Se usa vírgula como separador decimal, precisamos informar dec = ",".

6. Importando dados da internet

Também podemos importar dados diretamente de uma URL.

Nesta seção, vamos usar a base Iris, uma base clássica e didática com medidas de flores. Ela possui informações como comprimento e largura das sépalas e pétalas, além da espécie da flor.

Comentário do professor

Quando usamos uma URL como argumento em read.table(), o R tenta acessar o arquivo diretamente pela internet. Por isso, esse exemplo depende de conexão ativa.

Execute este código

url_iris <- paste0(
  "https://raw.githubusercontent.com/",
  "pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv"
)

dados_iris <- read.table(
  file = url_iris,
  header = TRUE,
  sep = ",",
  dec = "."
)

head(dados_iris)

Comentário do professor

Neste exemplo:

A função paste0()junta textos sem inserir espaços entre eles. Neste exemplo, usamos past0()apenas para deixar a URL mais organizada no código:

Também poderia ser escrito diretamente assim:

url_iris <- "https://raw.githubusercontent.com/pandas-dev/pandas/main/pandas/tests/io/data/csv/iris.csv"

• file = url_iris: indica que o arquivo será lido diretamente de uma URL.
• header = TRUE: informa que a primeira linha do arquivo contém os nomes das colunas.
• sep = ",": informa que as colunas estão separadas por vírgula.
• dec = ".": informa que os números usam ponto como separador decimal.

Depois de importar dados da internet, é interessante conferir a estrutura do objeto criado.

Execute este código

str(dados_iris)

'data.frame':   150 obs. of  5 variables:
 $ SepalLength: num  5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
 $ SepalWidth : num  3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
 $ PetalLength: num  1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
 $ PetalWidth : num  0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
 $ Name       : chr  "Iris-setosa" "Iris-setosa" "Iris-setosa" "Iris-setosa" ...

summary(dados_iris)

  SepalLength      SepalWidth     PetalLength      PetalWidth   
 Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100  
 1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300  
 Median :5.800   Median :3.000   Median :4.350   Median :1.300  
 Mean   :5.843   Mean   :3.054   Mean   :3.759   Mean   :1.199  
 3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800  
 Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500  
     Name          
 Length:150        
 Class :character  
 Mode  :character  
                   
                   
                   

Comentário do professor

Esse tipo de importação depende de conexão com a internet. Quando os dados forem importantes para uma análise, pode ser uma boa ideia salvá-los localmente.

7. Usando funções específicas para .csv

Além de read.table(), existem funções específicas para arquivos .csv.

7.1 read.csv()

Execute este código

dados_csv <- read.csv(
  file = "producao.csv",
  sep = ";",
  dec = "."
)

dados_csv

7.2 read.csv2()

Comentário do professor

A função read.csv2() é útil quando o arquivo usa ; como separador de colunas e , como separador decimal, padrão comum em arquivos gerados no Brasil.

Execute este código

dados_brasil <- data.frame(
  trt = c(1, 1, 2, 2, 3, 3),
  y = c(19.4, 32.6, 17.7, 24.8, 17.0, 19.4)
)

write.table(
  x = dados_brasil,
  file = "dados_brasil.csv",
  sep = ";",
  dec = ",",
  quote = FALSE,
  row.names = FALSE
)

dados_brasil_lido <- read.csv2("dados_brasil.csv")

dados_brasil_lido

8. Verificando dados importados

Depois de importar uma base, devemos verificar se ela foi lida corretamente.

Execute este código

str(dados_producao)

'data.frame':   10 obs. of  2 variables:
 $ x: int  1 2 3 4 5 6 7 8 9 10
 $ y: num  6.7 7.9 9.1 6.6 7.5 8.8 7.7 7.6 6.5 7.9

head(dados_producao)

summary(dados_producao)

       x               y       
 Min.   : 1.00   Min.   :6.50  
 1st Qu.: 3.25   1st Qu.:6.90  
 Median : 5.50   Median :7.65  
 Mean   : 5.50   Mean   :7.63  
 3rd Qu.: 7.75   3rd Qu.:7.90  
 Max.   :10.00   Max.   :9.10  

Comentário do professor

Depois de importar dados, sempre confira:

• As primeiras linhas.
• A estrutura das colunas.
• O tipo de cada variável.
• Se os números foram lidos como números.
• Se textos não foram lidos de forma estranha.

9. Exportando arquivos de texto

A função write.table() permite exportar objetos do R, como dataframes e matrizes, para arquivos de texto.

Comentário do professor

A lógica de exportação para .txt, .csv e .csv2 é muito parecida. O que muda principalmente são os argumentos sep e dec.

Resumo dos formatos

Formato	Separador de colunas	Separador decimal	Função equivalente
.txt	tabulação ou espaço	ponto	write.table()
.csv	vírgula	ponto	write.csv()
.csv2	ponto e vírgula	vírgula	write.csv2()

9.1 Criando um dataframe para exportação

Execute este código

resultado <- data.frame(
  grupo = c("A", "B", "C"),
  media = c(2.55, 1.36, 2.27)
)

resultado

9.2 Exportando como .txt

Execute este código

write.table(
  x = resultado,
  file = "resultado.txt",
  sep = "\t",
  quote = FALSE,
  row.names = FALSE
)

Comentário do professor

Neste exemplo, usamos sep = "\t", que indica separação por tabulação. Esse formato costuma organizar bem os dados em arquivos .txt.

9.3 Exportando como .csv

Execute este código

write.table(
  x = resultado,
  file = "resultado.csv",
  sep = ",",
  dec = ".",
  quote = FALSE,
  row.names = FALSE
)

Comentário do professor

O formato .csv tradicional usa vírgula para separar colunas e ponto como separador decimal.

Também podemos usar a função atalho write.csv().

Execute este código

write.csv(
  x = resultado,
  file = "resultado_write_csv.csv",
  row.names = FALSE
)

9.4 Exportando como .csv2

Execute este código

write.table(
  x = resultado,
  file = "resultado_csv2.csv",
  sep = ";",
  dec = ",",
  quote = FALSE,
  row.names = FALSE
)

Comentário do professor

O formato .csv2 é muito comum no Brasil, pois usa ponto e vírgula para separar colunas e vírgula como separador decimal.

Também podemos usar a função atalho write.csv2().

Execute este código

write.csv2(
  x = resultado,
  file = "resultado_write_csv2.csv",
  row.names = FALSE
)

9.5 Lendo os arquivos exportados

Execute este código

resultado_txt <- read.table(
  file = "resultado.txt",
  header = TRUE,
  sep = "\t"
)

resultado_csv <- read.table(
  file = "resultado.csv",
  header = TRUE,
  sep = ",",
  dec = "."
)

resultado_csv2 <- read.table(
  file = "resultado_csv2.csv",
  header = TRUE,
  sep = ";",
  dec = ","
)

resultado_txt

resultado_csv

resultado_csv2

Atenção

Ao importar um arquivo, os argumentos usados na leitura devem ser compatíveis com os argumentos usados na exportação. Se você exportou com sep = ";", precisa importar considerando esse mesmo separador.

10. Salvando objetos do R

Além de exportar arquivos .txt e .csv, podemos salvar objetos no formato próprio do R.

10.1 Arquivos .RData

Arquivos .RData podem armazenar um ou mais objetos.

Execute este código

save(
  dados_alfafa,
  dados_producao,
  file = "dados_aula3.RData"
)

list.files()

 [1] "alfafa.txt"               "aula3_files"             
 [3] "aula3.html"               "aula3.qmd"               
 [5] "aula3.rmarkdown"          "clientes.csv"            
 [7] "dados_aula3.RData"        "dados_brasil.csv"        
 [9] "estilo.css"               "notas.RData"             
[11] "notas.rds"                "notas.txt"               
[13] "producao.csv"             "resultado_csv2.csv"      
[15] "resultado_write_csv.csv"  "resultado_write_csv2.csv"
[17] "resultado.csv"            "resultado.rds"           
[19] "resultado.txt"            "resultado.xlsx"          
[21] "rsconnect"               

Execute este código

rm(dados_alfafa, dados_producao)

ls()

 [1] "alfafa"            "dados_brasil"      "dados_brasil_lido"
 [4] "dados_csv"         "dados_iris"        "producao"         
 [7] "resultado"         "resultado_csv"     "resultado_csv2"   
[10] "resultado_txt"     "url_iris"         

load("dados_aula3.RData")

ls()

 [1] "alfafa"            "dados_alfafa"      "dados_brasil"     
 [4] "dados_brasil_lido" "dados_csv"         "dados_iris"       
 [7] "dados_producao"    "producao"          "resultado"        
[10] "resultado_csv"     "resultado_csv2"    "resultado_txt"    
[13] "url_iris"         

Atenção

Ao usar load(), objetos com o mesmo nome podem ser sobrescritos no ambiente global.

10.2 Arquivos .rds

Arquivos .rds armazenam um único objeto.

Execute este código

saveRDS(
  object = resultado,
  file = "resultado.rds"
)

resultado_recuperado <- readRDS("resultado.rds")

resultado_recuperado

Comentário do professor

A vantagem do .rds é que podemos escolher o nome do objeto no momento da leitura.

11. Diferença entre .RData, .rda e .rds

Resumo

• .RData e .rda: armazenam um ou mais objetos.
• .rds: armazena um único objeto.
• save() cria arquivos .RData ou .rda.
• load() lê arquivos .RData ou .rda.
• saveRDS() cria arquivos .rds.
• readRDS() lê arquivos .rds.

12. Introdução a arquivos Excel

Arquivos .xlsx são muito comuns, mas geralmente exigem pacotes adicionais.

Comentário do professor

Para utilizar as funções que trabalham com arquivos do Excel, é necessário instalar os pacotes readxl e writexl.

A instalação é feita apenas uma vez, utilizando a função install.packages():

install.packages("readxl")
install.packages("writexl")

Após instalar, não é necessário instalar novamente.

Para usar as funções desses pacotes, podemos carregá-los com:

library(readxl)
library(writexl)

Ou utilizar a forma direta com ::, como nos exemplos da aula:

readxl::read_excel("arquivo.xlsx")
writexl::write_xlsx(dados, "arquivo.xlsx")

Atenção

A instalação install.packages() deve ser feita apenas uma vez.

O carregamento library() deve ser feito sempre que iniciar uma nova sessão no R.

12.1 Exportando para Excel com writexl

Execute este código

if (requireNamespace("writexl", quietly = TRUE)) {
  writexl::write_xlsx(
    x = resultado,
    path = "resultado.xlsx"
  )
  
  list.files()
} else {
  message("O pacote writexl não está instalado.")
}

 [1] "alfafa.txt"               "aula3_files"             
 [3] "aula3.html"               "aula3.qmd"               
 [5] "aula3.rmarkdown"          "clientes.csv"            
 [7] "dados_aula3.RData"        "dados_brasil.csv"        
 [9] "estilo.css"               "notas.RData"             
[11] "notas.rds"                "notas.txt"               
[13] "producao.csv"             "resultado_csv2.csv"      
[15] "resultado_write_csv.csv"  "resultado_write_csv2.csv"
[17] "resultado.csv"            "resultado.rds"           
[19] "resultado.txt"            "resultado.xlsx"          
[21] "rsconnect"               

12.2 Importando Excel com readxl

Execute este código

if (
  requireNamespace("readxl", quietly = TRUE) &&
    file.exists("resultado.xlsx")
) {
  resultado_excel <- readxl::read_excel("resultado.xlsx")
  
  resultado_excel
} else {
  message("Instale readxl e verifique se o arquivo resultado.xlsx existe.")
}

13. Exercícios

Orientação

Construam um script em R com as resoluções dos exercícios e salvem esse arquivo em uma pasta pessoal.

13.1 Exercícios sobre diretório de trabalho

Exercício 1

Use uma função para verificar o diretório de trabalho atual.

getwd()

[1] "/Users/marcelocarlosribeiro/Documents/2026.1/EST 128/Aulas/Aula 3 "

Exercício 2

Use uma função para listar os arquivos existentes no diretório de trabalho.

list.files()

 [1] "alfafa.txt"               "aula3_files"             
 [3] "aula3.html"               "aula3.qmd"               
 [5] "aula3.rmarkdown"          "clientes.csv"            
 [7] "dados_aula3.RData"        "dados_brasil.csv"        
 [9] "estilo.css"               "notas.RData"             
[11] "notas.rds"                "notas.txt"               
[13] "producao.csv"             "resultado_csv2.csv"      
[15] "resultado_write_csv.csv"  "resultado_write_csv2.csv"
[17] "resultado.csv"            "resultado.rds"           
[19] "resultado.txt"            "resultado.xlsx"          
[21] "rsconnect"               

13.2 Exercícios sobre importação e exportação

Exercício 3

Crie um dataframe chamado clientes com as colunas nome, idade e cidade. Depois exporte esse dataframe para um arquivo chamado clientes.csv.

clientes <- data.frame(
  nome = c("Ana", "Bruno", "Carla"),
  idade = c(25, 31, 28),
  cidade = c("Ouro Preto", "Mariana", "Belo Horizonte")
)

write.table(
  x = clientes,
  file = "clientes.csv",
  sep = ";",
  quote = FALSE,
  row.names = FALSE
)

Exercício 4

Importe o arquivo clientes.csv e salve o resultado no objeto clientes_lidos.

clientes_lidos <- read.table(
  file = "clientes.csv",
  header = TRUE,
  sep = ";"
)

clientes_lidos

Exercício 5

Verifique a estrutura do objeto clientes_lidos.

str(clientes_lidos)

'data.frame':   3 obs. of  3 variables:
 $ nome  : chr  "Ana" "Bruno" "Carla"
 $ idade : int  25 31 28
 $ cidade: chr  "Ouro Preto" "Mariana" "Belo Horizonte"

Exercício 6

Crie um dataframe chamado notas com as colunas aluno, nota1 e nota2. Depois crie uma coluna chamada media.

notas <- data.frame(
  aluno = c("Ana", "Bruno", "Carla"),
  nota1 = c(8.0, 6.5, 9.0),
  nota2 = c(7.5, 7.0, 8.5)
)

notas$media <- (notas$nota1 + notas$nota2) / 2

notas

Exercício 7

Exporte o dataframe notas para um arquivo chamado notas.txt, separado por tabulação.

write.table(
  x = notas,
  file = "notas.txt",
  sep = "\t",
  quote = FALSE,
  row.names = FALSE
)

13.3 Exercícios sobre .RData e .rds

Exercício 8

Salve o objeto notas em um arquivo chamado notas.RData.

save(notas, file = "notas.RData")

Exercício 9

Salve o objeto notas em um arquivo chamado notas.rds.

saveRDS(
  object = notas,
  file = "notas.rds"
)

Exercício 10

Leia o arquivo notas.rds e salve o resultado em um novo objeto chamado notas_recuperadas.

notas_recuperadas <- readRDS("notas.rds")

notas_recuperadas

Comentário do professor

Importar e exportar dados é uma etapa fundamental da análise de dados. Antes de analisar uma base, precisamos garantir que ela foi lida corretamente pelo R.