Importação e Exportação de Dados

Programação
Introdução
Importação de dados
workflows
Como importar dados de ficheiros para o R e como gravar dados em ficheiros.
Autores
Afiliações

João O. Santos

ISPA

Cristina Mendonça

ISPA; WJCR

Vitória Melita

FP-UL

Mariona Pascual Peñas

UIB

João Raposo

ISPA

Marta Barros

FP-UL

0 Importação e Exportação de Dados

Para importarmos bases dados, precisamos duma função que saiba “ler” o formato do ficheiro em que temos os nossos dados e guardar o output dessa função, numa variável. Sempre que trabalharmos com a variável estamos a trabalhar com os dados que estavam no ficheiro. Contudo, as alterações que fizermos à variável não alteram o ficheiro. Para guardarmos as alterações num ficheiro temos de fazer o processo inverso. Ou seja, precisamos de uma função que saiba “escrever” a nossa variável num ficheiro do formato em que queiramos guardar os dados.

Em baixo podem ver um exemplo de um script que ilustra este processo.

# Cria a variável dados que guarda o output da função que lê o ficheiro.
dados <- read.csv("../data/demo_ds.csv")

# Depois viria o código que limpa, reformata, e analisa os dados.

# Executa a função que grava a variável dados num novo ficheiro.
write.csv(dados, "../data/novo_ficheiro.csv", row.names = FALSE)

Nota: row.names = FALSE evita que se grave nomes das linhas. Quando importamos um csv os nomes das linhas são o número das linhas e não é muito útil ter essa informação.

Ao longo deste tutorial vamos aprender os conceitos necessários para importar e exportar bases de dados com segurança. É possível que muitos dos conceitos explicados no tutorial sejam novos para vocês e pareçam complicados. Contudo, a maioria desses conceitos não são exclusivos ao R mas à forma como os computadores funcionam. Ou seja, não pensem que estão a ter dificuldades na estatística ou no uso do R, se os conceitos parecerem complicados. Essas serão dificuldades que podiam sentir a usar outros programas informáticos, e que ao ultrapassarem vos tornarão melhores utilizadores de todos os programas e não só do R.

Caminhos para Ficheiros

Nos exemplos anteriores invocámos a função read.csv() com o nome do nosso ficheiro como argumento.

Contudo, na maioria dos casos não podemos apenas usar o nome do ficheiro mas sim o caminho/localização do ficheiro. Não se assustem se não conhecerem os termos, o caminho ou localização do ficheiro é apenas a sequência de directórios/pastas pelos quais temos de passar para chegar ao ficheiro.

Por exemplo, imaginem que temos um ficheiro chamado exemplo.R, dentro dum directório/pasta chamado scripts_R, que por sua vez está dentro doutro chamado documentos. Se estivermos a trabalhar no directório documentos para chegarmos ao ficheiro só temos de “percorrer” o caminho scripts_R/exemplo.R. Porém se estivéssemos a trabalhar dentro do directório scripts_R, não haveria nenhum directório entre nós e o ficheiro, portanto bastaria usar o nome do ficheiro exemplo.R. Por outro lado, se estivéssemos dentro dum directório nome_de_utilizador, que tivesse lá dentro o directório documentos, para chegarmos ao ficheiro exemplo.R teríamos de “percorrer” o caminho documentos/scripts_R/exemplo.R.

Possíveis Problemas

Com base no exemplo anterior, podemos concluir que:

  1. Não basta saber o nome do ficheiro, precisamos de saber o caminho que temos de “percorrer” para chegar até ele

  2. O caminho que temos de “percorrer” para chegar até ao ficheiro é sempre relativo ao nosso ponto de partida, ou seja, o directório em que estamos a trabalhar.

Sabendo isto, é provável que vos surjam algumas perguntas:

  • Se os caminhos são sempre relativos ao directório em que estamos a trabalhar, como é que podemos ter a certeza que o nosso script vai funcionar?

  • Corremos sempre o risco que o R não encontre o ficheiro por lhe dar um caminho errado?

  • Achas mesmo que vou decorar o caminho para todas as minhas bases de dados? Podes tirar o cavalinho da chuva! Vou voltar para o SPSS!

Começando do fim para o início:

Achas mesmo que vou decorar o caminho para todas as minhas bases de dados?

Não acho…nem nunca o terás de o fazer.

Podes tirar o cavalinho da chuva! Vou voltar para o SPSS!

Tanta agressividade… Calma…o problema não é assim tão complicado e há soluções muito simples.

Corremos sempre o risco que o R não encontre o ficheiro por lhe dar um caminho errado?

Sim…mas usando qualquer uma das soluções abaixo reduzem muito a probabilidade de se depararem com esses problemas. Para além disso, veremos que isto não são limitações do R, mas características de todos os computadores.

Se os caminhos são sempre relativos ao directório em que estamos a trabalhar, como é que podemos ter a certeza que o nosso script vai funcionar?

Usando qualquer uma das soluções abaixo…

Possíveis Soluções

Opção 1

A solução talvez considerem mais simples é usar a função file.choose() para o R vos deixar procurar pelo ficheiro e gravar o caminho até lá.

caminho <- file.choose() # grava o caminho na variável caminho.
dados <- read_xlsx(caminho) # importa o ficheiro que está no caminho.

Opção 2

Podemos adaptar a Opção 1 de modo a só precisarmos de seleccionar o ficheiro enquanto estamos a escrever o código a primeira vez e nunca mais termos de repetir o processo.

Para isso quando estamos a escrever o código pela primeira vez executemos a função file.choose() no interpretador e copiemos o seu output para o script.

No interpretador:

file.choose()

# Possível output em UNIX (Linux, BSDs, macOS).
[1] "/home/nome_de_utilizador/documentos/data/demo_ds.csv"

# Possível output em Windows.
[1] "C://Users/nome_de_utilizador/documentos/data/demo_ds.csv"

No script:

dados <- read.csv("/home/nome_de_utilizador/documentos/data/demo_ds.csv")
# Ou em Windows:
dados <- read.csv("C://Users/nome_de_utilizador/documentos/data/demo_ds.csv)"

Desde que não alteremos o nome e/ou a localização do ficheiro, das próximas que vezes que executemos o script não precisaremos de seleccionar o ficheiro porque a sua localização já está no script.

Opção 3

Outra opção será trabalharmos sempre a partir do mesmo directório e escrever todos os caminhos tomando esse relatório como referência.

No R, para definirmos o working directory (i.e., o directório a partir do qual trabalhamos) usamos a função setwd() (set working directory).

# Sistemas UNIX (Linux, BSDs, macOS).
setwd("/home/nome_de_utilizador/documentos/")
# com interface gráfica
setwd(dirname(file.choose()))
# (basta seleccionarmos um qualquer ficheiro no directório documentos)

# Sistemas Windows.
setwd("C://Users/nome_de_utilizador/documentos/")
# com interface gráfica
setwd(dir.choose())

Nota: Os IDEs como o RStudio costumam ter funcionalidades que nos permitem definir o working directory usando uma interface gráfica. Deve bastar fazerem uma pesquisa rápida na internet para a descobrir (e.g., “Google: How to set working directory in RStudio”).

A partir do momento que temos o nosso working directory definido, podemos escrever todos os caminhos como partindo desse directório/pasta. Não nos podemos é esquecer que temos sempre de definir o nosso working directory antes de executarmos código que assume que os caminhos partem do working directory.

Imaginemos que dentro do nosso working directory temos um ficheiro chamado study1.csv. Nesse caso, poderemos dizer que o caminho até ao ficheiro é simplesmente o seu nome—"study1.csv"—dado que não temos que atravessar nenhum directório/pasta para lá chegar.

Nesse caso para lermos os dados contidos no ficheiro study1.csv e guardá-los na variável dados bastaria:

dados <- read.csv("study1.csv")

Imaginemos que afinal o ficheiro study1.csv não está directamente no nosso working directory, mas sim dentro duma pasta data que está dentro do working directory. Nesse caso, para chegar até ao ficheiro temos que passar pela pasta data. Temos então de especificar o caminho até ao ficheiro como "data/study1.csv".

Podemos reescrever o código anterior como:

dados <- read.csv("data/study1.csv")

Caso não saibam de cor o caminho até ao ficheiro mas tenham a certeza que está algures num directório/pasta do vosso working directory podem fazer o que aprendemos na “Opção 2”. Mais concretamente, podem usar a função file.choose() para descobrir o caminho através duma interface gráfica e colar o output no script. Desde que tenham definido o working directory antes de executar a função file.choose(), o output da função file.choose() deverá ser o caminho até ao ficheiro a partir pelo vosso working directory.

No interpretador (ou usando uma funcionalidade do IDE, e.g., RStudio):

setwd("/home/nome_de_utilizador/documentos/")

No interpretador:

file.choose()

# Possível output.
[1] "data/study1.csv"

No script:

dados <- read.csv("data/study1.csv")

Opção 4

Podemos adaptar a “Opção 3” ligeiramente, e em vez de definirmos um directório onde vamos trabalhar em todas as análises que alguma vez façamos, termos um directório onde vamos trabalhar em todas as análises dum projecto específico. Ou seja, passamos a definir um working directory para cada projecto/estudo em que trabalhamos.

Por exemplo, para os meus estudos costumo criar um directório stats que tem lá dentro três directórios data, analyzes, e results. Guardo todos os scripts do R no directório analyzes, as bases de dados no data e os outputs mais importantes das análises em results. Assim só tenho de executar os scripts a partir do directório analyzes desse projecto.

# Para um projecto X
setwd("/home/nome_de_utilizador/projectos/projecto_X/stats/analyzes")

# Para um projecto Y
setwd("/home/nome_de_utilizador/projectos/projecto_Y/stats/analyzes").`

Depois posso escrever os scripts de cada projecto como partindo do directório analyzes e usar a abreviatura ../ para chegar ao directório anterior (neste caso stats).

dados <- read.csv("../data/demo_ds.csv")
# Seria igual a: 
# dados <- read.csv("/home/nome_de_utilizador/projectos/projecto_X/stats/data/demo_ds.csv")

A vantagem desta abordagem é que se alguém copiar todo o directório do projecto_X para o seu computador só tem de definir como a pasta projecto_X/stats/analyzes como working directory que todos os scripts vão funcionar.

# Para o projecto X no computador doutra pessoa.
setwd("/home/o_seu_nome_de_utilizador/documentos/projectos_copiados/projecto_X/stats/analyzes")

Como o setwd() é diferente para cada pessoa, mas o restante código é igual, o setwd() não deve ficar no script que é partilhado. Portanto, nunca nos podemos esquecer de fazer setwd() antes de começar a trabalhar! Por outro lado, podemos usar as funções do nosso IDE (e.g., RStudio) para fazer esse passo sem problema.

Formatos/Tipos de Ficheiros

Para podermos ler um ficheiro precisamos de saber não só a sua localização mas o seu formato. Regra geral o formato/tipo do ficheiro pode ser inferido a partir da extensão dum ficheiro. Por exemplo, se um ficheiro termina em .csv podemos inferir que é um csv (comma separated values), se termina em .xlsx inferimos que é um ficheiro do Microsoft Excel, se termina em .sav inferimos que vem do SPSS.

O R traz consigo a possibilidade de ler ficheiros de texto simples em formatos como csv e tsv mas não ficheiros mais complexos como .xlsx ou .sav. Contudo, temos quase sempre disponíveis pacotes que podemos instalar para passarmos a ter funções capazes de ler esses formatos mais complexos. Aconselho-vos portanto a tentarem gravar as bases de dados em csv, sempre que possível. Nestes tutoriais esse será o formato usado. Dito isto, será muito fácil adaptarem o que aprenderem aqui para trabalhar com bases de dados noutros formatos.

Por exemplo, se os dados do ficheiro study1.csv também estivessem no formato xlsx, num ficheiro chamado study1.xlsx eu poderia usar a função read_xlsx(), do pacote readxl para os ler.

dados <- read_xlsx("../data/demo_ds.csv")

Claro que para utilizarmos um pacote temos primeiro que o instalar (e.g., install.packages("readxl")) e depois temos de o carregar para a sessão (e.g., library(readxl)). Vamos aprender a actualizar, instalar, e usar pacotes noutro tutorial, para já vamos ficar pelos csv e não vamos precisar de nenhum pacote especial.

Variávei/Objectos vs Ficheiros

Quando trabalharmos com ficheiros no R convém lembrarmo-nos de algumas regras, que vão parecer confusas ao início, mas que depois nos vamos habituar a cumprir sem ter de pensar nelas. Para percebermos o porquê dessas regras temos de perceber a diferença entre ambiente e ficheiros. Vamos por partes…

Regras

  1. Garantir que tenho sempre uma cópia/backup de bases de dados e ficheiros importantes.

  2. Tenho de guardar o output da função que lê o ficheiro numa variável.

  3. Os objectos/variáveis não são ficheiros e os ficheiros não são objectos/variáveis.

  4. Quando guardo uma coisa num objecto ou ficheiro apago a informação que lá estava e nunca mais terei acesso a ela.

Estas regras podem traduzir-se em recomendações mais concretas:

  1. Antes de trabalhar com dados importantes garanto que tenho uma cópia/backup num disco externo, numa pen/usb, noutro computador, ou nuvem/cloud (e.g., email, Google Drive). Caso não tenha essa cópia/backup aproveito para a criar antes de começar a trabalhar.

  2. Devo devo guardar sempre o output da função que o leu numa variável e trabalhar sempre com essa variável. Não vale a pena importar a base de dados sempre que a vou usar num script. Importo-a para uma variável no início do script e depois trabalho com essa variável.

  3. As alterações que eu faço ao objecto/variável que tem o output da função que leu os meus dados não alteram o ficheiro original. Ou seja, se apago uma coluna da variável/objecto que tem a base de dados essa coluna não desaparece do ficheiro. Ao mesmo tempo, se apagar uma coluna do ficheiro e não o voltar a importar para essa mesma a variável/objecto, essa coluna não desaparece da variável/objecto.

  4. Quando guardo alguma coisa numa variável/objecto apago toda a informação que lá estava. Do mesmo modo, quando guardo alguma coisa num ficheiro perco a informação que lá estava. Se eu quiser guardar as alterações que fiz a uma base de dados num ficheiro tenho de usar uma função para “escrever” a variável com as alterações para um novo ficheiro. Se eu usar uma função para escrever uma variável para um ficheiro que já exista perco a informação que estava originalmente no ficheiro. Isso pode ser algo muito útil ou catastrófico dependendo do meu objectivo. Por isso é que tenho sempre de cumprir a primeira regra e fazer cópias/backups.

Ambiente vs. Ficheiros

Quando trabalhamos no R vamos criando objectos/variáveis que ficam no nosso ambiente. O ambiente de trabalho funciona como uma bancada de trabalho onde vamos pondo as coisas (i.e., variáveis/objectos) em que estamos a trabalhar. Contudo ao contrário duma bancada de trabalho normal, no R quando acabamos de trabalhar o ambiente é completamente limpo indo tudo parar ao “lixo”. Por isso, se quisermos guardar algum objecto/variável (e.g., uma base de dados, resultado dum teste) para acedermos sem termos de abrir o R temos de escrever esse objecto/variável num ficheiro.

No nosso computador, quer tenhamos ou não o R instalado, temos vários ficheiros. Se eu tiver fotografias, vídeos, livros, etc. no meu computador esses ficheiros continuam lá quer estejam a ser usados ou não. Se eu estiver a ler um pdf esse pdf vai continuar lá depois de eu sair do programa que estou a usar para o ler. Quando os programas lêem um ficheiro é como se ficassem com os conteúdos no seu ambiente como o R faz. Quando abro um documento de texto posso fazer as alterações que eu quiser se fechar o programa sem gravar as alterações o o ficheiro vai continuar lá igual ao que estava. Caso eu grave as alterações o ficheiro deixa de ter a informação que tinha antes e passa a ter a informação alterada.

Nota: Se se lembram das aulas de TIC ou gostam de informática, podem lembrar-se que o ambiente do R fica na memória RAM enquanto temos o R aberto naquela sessão. Quando saímos do R essa memória é devolvida ao sistema operativo para ser usada por outros programas. Quando desligamos o computador essa memória é completamente apagada. Os ficheiros vivem no disco do nosso computador (seja um disco rígido ou um SSD) esse disco guarda a nossa informação para sempre (até se estragar). Podemos desligar o computador, arrancar o disco, inseri-lo noutro computador que a informação vai continuar lá.

Em suma, as variáveis/objectos podem ter a informação que está em ficheiros mas se eu as alterar não altero o ficheiro. Para alterar um ficheiro tenho de gravar uma variável/objecto nessa localização/caminho.

R vs. Outros Programas

Nesta altura podem pensar:

“O R é mesmo difícil! Eu não tenho de saber nada disto para trabalhar com os outros programas!”.

Compreendo o sentimento, contudo não corresponde totalmente à realidade. Reparem que os directórios e caminhos de ficheiros não foram inventados pelo R, nem são exclusivos do R, mas sim um conceito básico do sistema operativo.

Podem então responder:

“Há anos que uso computadores e nunca tive de saber nada disto!”.

Mais uma vez, compreendo o sentimento mas não corresponde totalmente à realidade. Cada vez que “abriram uma pasta” no computador ou “seleccionaram um ficheiro” estavam e especificar o caminhos até ficheiros.

De certeza que já clicaram duas vezes no ícone duma pasta (e.g., documentos) e clicaram mais duas no ícone doutra pasta que estivesse lá dentro (e.g., fotografias). Nesse caso tudo o que fizeram foi usar uma interface gráfica para dizer ao computador abre o directório documentos/fotografias. Quando seleccionaram um ficheiro (e.g., ParaPostarNoInsta.jpeg), ao clicar no seu ícone, depois de terem clicado em várias pastas até chegar até ao ficheiro, estavam a dizer ao computador abre o ficheiro no caminho documentos/fotografias/ParaPostarNoInsta.jpeg.

Quando abrem uma base de dados (e.g., study1.csv) no JASP no Jamovi ou SPSS estão a dizer a esse programa “abre o ficheiro que está no caminho que te vou indicar” (e.g.,/home/nome_de_utilizador/documentos/data/study1.csv).

Quando fazem “guardar” estão a dizer ao programa que estão a usar para guardar o/s objecto/s que tem no seu ambiente/memória no mesmo caminho que lhe indicaram quando abriram o ficheiro. Quando fazem “guardar como” estão a dizer ao programa para criar um ficheiro com o nome que escolheram no caminho que lhe indicaram.

O R não é diferente dos outros programas no que toca a abrir e guardar ficheiros. Assim como os outros programas, o R vai abrir ou guardar o ficheiro no caminho que indicarem. No R podemos habituar-nos a escrever o caminho para os ficheiros em vez dos indicarmos clicando em ícones de pastas e ficheiros. Mesmo assim, já viram que nada nos impede de usarmos funções como file.choose() para escolher os ficheiros com uma interface gráfica. A diferença é que no R temos de escolher a função que queremos usar para abrir cada ficheiro e decidir em que variável queremos guardar os dados extraídos do ficheiro.

Exercícios

Exercício 1

  • Descarregue o ficheiro demo_ds.csv clicando no link e guardando algures no seu computador (e.g., no ambiente de trabalho)

  • Importe o ficheiro usando a função apropriada para ler uma base de dados guardada neste tipo de ficheiro (reler o capítulo se necessário) e a função capaz de abrir uma interface gráfica para encontrar o ficheiro (reler capítulo se necessário). Corra head(ds) para confirmar que importou o ficheiro correctamente.

  • Use a função capaz de abrir uma interface gráfica que usou anteriormente, selecione o mesmo ficheiro e tome nota do caminho que ela retorna.

  • Use a mesma função capaz de ler tabelas csv para abrir o ficheiro mas desta vez dê-lhe como argumento a string com o caminho para o ficheiro que obteve anteriormente.

Soluções

Clique para ver as soluções 
ds <- read.csv(file.choose())
head(ds)

file.choose()

ds <- read.csv("/home/random_user/demo_ds.csv")
# Ou em sistemas Windows algo deste estilo:
#ds <- read.csv("C://Users/random_user/Desktop/demo_ds.csv")