Lendo os Dados

Antes de começarmos …

Antes da “leitura” dos dados, é importante organizarmos nosso projeto.

Aconselhei criar uma pasta em “Meus Documentos” com o nome “projetos_em_R”. Nessa pasta colocaremos todas nossas análises feitas com o R.

Então, dentro da pasta “projetos_em_R” vamos criar nosso diretório de trabalho, que nada mais é do que uma outra pasta com o nome do projeto que estamos realizando.

Para essa análise, vamos denominar tidyverse_readr. Então, de uma forma geral, teríamos algo assim:

.
└── projetos_em_R/
    └── tidyverse_readr/

Para criarmos isso, vamos usar o pacote usethis (que já deveria estar previamente instalado)¹. Esses são os passos:

Abra o R Studio;
No Console, digite: usethis::create_project("projetos_em_R/tidyverse_readr")
Dê Enter.

Depois de um Checklist interno, abrirá uma nova seção do R Studio (você pode fechar a anterior). A imagem fica mais ou menos assim:

Note que, no Quadrande IV, foram criados o arquivo .gitignore; uma pasta R e um projeto do R Studio denominado tidyverse.Rproj. Seu diretório, agora, deve ficar assim:

.
└── tidyverse_readr/
    ├── .gitignore
    ├── R/
    └── tidyverse.Rproj

É uma boa prática criarmos uma pasta para colocarmos os dados brutos (raw, em inglês) e os dados arrumados (tidy).

Então, seu diretório de trabalho deve conter, pelo menos, uma estrutura assim:

.
└── tidyverse_readr/     # diretório do projeto atual
    ├── .gitignore       # arquivo para ignorar versionamentos em alguns casos
    ├── dados/           # diretório dos datasets
    │   ├── brutos/      # dataset "bruto"
    │   └── tidy/        # dataset "arrumado"
    ├── R/               # diretório para salvar os `scripts` em R
    └── tidyverse.Rproj  # arquivo que abre o seu projeto no R Studio

Você pode fazer isso clicando com o botão direito do mouse dentro do diretório “tidyverse_readr” e criar as pastas, renomeando-as; ou usar, mais uma vez, o pacote usethis, com a função use_directory(), da seguinte forma:

usethis::use_directory("dados")), para criar o diretório “dados”;
usethis::use_directory("dados/brutos"), para criar a subpasta “brutos”, dentro do diretório “dados”;
usethis::use_directory("dados/tidy"), para criar a subpasta “tidy”, dentro do diretório “dados”.

Alternativamente, você pode pode criar esses diretórios de uma única vez com o comando²:

usethis::use_directory(c("dados/brutos", "dados/tidy"))

Quando o número de datasets são elvados, alguns ainda organizam em subpastas os arquivos .csv, .xlsx, etc., dessa forma:

.
└── tidyverse_readr/
    ├── .gitignore
    ├── dados/
    │   ├── brutos/
    │   │   ├── csv/
    │   │   ├── xlsx/
    │   │   └── ...
    │   └── tidy/
    ├── R/
    └── tidyverse.Rproj

Essa última organização não utilizaremos, por conta de nossos fins (usaremos um exemplo de cada, o que não causaria confusão colocando-os na mesmo diretório/pasta)³

Feita a organização de seu diretório de trabalho, vamos endender um pouco mais sobre o pacote readr.

Mostre-me os dados!

Para que aconteça uma análise de dados, certamente precisamos de uma base de dados. O computador deve acessar e processar tais dados de forma correta.

Existem muitos formatos de dados, mas interessa-nos aqueles em formato de data frame, ou melhor, tibble, em que as colunas reprentam variáveis.

Mas, existem muitas formas de escrever uma tibble. Podemos separar suas colunas por vírgulas (“,”); espaços (" “); ponto e vírgula (”;“); barras verticais (”|"); dentre muitos outras. E o R possui funções e pacotes específicos para cada um deles.

Por exemplo, se escrevermos em um bloco de notas o texto a seguir:

Nome, Curso, Nota
Zeca, Matemática, 9.7
Asponjo, Matemática, 9.8
Teco, Química, 7.0
Titica, Química, 9.7
Astrobalda, Química, 9.0

E, depois, salvarmos com a extensão .csv; ao acessarmos adequadamente tal texto com o R, ele interpreta-o como uma “planilha” (tibble), assim:

## # A tibble: 5 x 3
##   Nome       Curso       Nota
##   <chr>      <chr>      <dbl>
## 1 Zeca       Matemática   9.7
## 2 Asponjo    Matemática   9.8
## 3 Teco       Química      7  
## 4 Titica     Química      9.7
## 5 Astrobalda Química      9

Para “leitura” desses dados, o R Base possui, por exemplo, uma familia de as funções read.xxx, onde xxx representa diversas extenções (csv, csv2, fortran, etc.). São proeminentes as funções: - read.csv(). Ela basicamente processa arquivos no formato .csv (comma-separated-values, ou seja, valores separados por vírgula); - read.csv2(). Processa arquivos separados por ponto e vírgula.

O tidyverse possui funções equivalentes à essas duas: - read_csv(), para ler arquivos separados por vírgulas - read_csv2(), para ler aquivos separados por ponto e vírgula.

As funções do tidyverse retornam uma tibble, enquanto as funções do R Base retornam um data frame. Uma não é melhor do que a outra! Cada uma pode ser usada em aspectos distinto. Embora as funções do tidyverse sejam contruídas com certas melhorais, em alguns casos exigem muito da memória do computador, mesmo em um banco de dados relatuvamente pequeno ( 500 Mb a 3 Gb)⁴ e, muitas vezes, precisamos recorrer às funções do R Base.

Mas, nesse curso, vamos usar apenas as funções listadas do tidyverse. Qual das duas usaremos? Aí dependerá de nossos dados. No exemplo citado acima, separamos as colunas por vírgulas e usamos o ponto como separador decimal. Nesse caso, usamos a função read_csv(). Mas, se as colunas fossem separadas por ponto e vírgula e a vírgula fosse o separador de decimais (que é o caso mais comum aqui no Brasil), usaríamos a função read_csv2(). A boa notícia é que ambas possuem a mesma estrutura de argumentos; e, por conta disso, vamos usar a read_csv() como explanação da teoria.

Mas, como fazemos?

Primeiro de tudo é carregar o pacote readr:

library(readr)

Mas, como geralmete não ficamos apenas no carregamento de dados, mas na manipulação e análise, é usual carregarmos o pacote tidyverse:

library(tidyverse)

Para exemplificação, consideremos um conjunto de dados denominado gordura_corporal.csv⁵, que se encontrará dentro do diretório brutos, como estabelecemos no início:

.
└── tidyverse_readr/
    ├── .gitignore
    ├── dados/
    │   ├── brutos/
    │   │   └── gordura_corporal.csv     
    │   └── tidy/
    ├── R/
    └── tidyverse.Rproj

A função read_csv() possui uma estrutura, mais ou menos assim:

read_csv("arquivo", arg-1, arg-2, ..., arg-n)

Em “arquivo”, colocamos (entre aspas) o caminho, junto com o nome do arquivo (incluindo sua extensão). Sobre os argumentos “arg-1”, “arg-2”, etc. falaremos oportunamente depois. Assim:

read_csv("dados/brutos/gordura_corporal.csv")

Obviamente, se você não organizar seus dados em uma pasta (o que não é aconselhável), mas deixá-los no diretório original, basta fazer:

read_csv("gordura_corporal.csv")

A saída, no console, fica assim:

## # A tibble: 100 x 10
##    indice_gordura idade  peso altura pescoco peito abdomen tornozelo biceps
##             <dbl> <dbl> <dbl>  <dbl>   <dbl> <dbl>   <dbl>     <dbl>  <dbl>
##  1           32.3    41  247.   73.5    42.1 117     116.       26.3   37.3
##  2           22.5    31  177.   71.5    36.2 101.     92.4      24.6   30.1
##  3           22      42  156.   69      35.5  97.8    86        24     31.2
##  4           12.3    23  154.   67.8    36.2  93.1    85.2      21.9   32  
##  5           20.5    46  177    70      37.2  99.7    95.6      22.5   29.1
##  6           22.6    54  198    72      39.9 108.    100        22     35.9
##  7           28.7    43  200.   71.5    37.9 107.    103.       23.7   32.1
##  8           21.3    42  163    70.2    35.3  93.5    89.6      21.9   30.7
##  9           29.9    37  241.   71.5    42.1 119.    110.       24.8   34.4
## 10           21.3    41  218.   71      39.8 112.    100.       25.2   37.5
## # ... with 90 more rows, and 1 more variable: pulso <dbl>

É importante salvarmos essa tibble em uma variável par que possamos acessá-la na memória do computador e manipularmos em outras etapas. Vou nomear com o mesmo nome do arquivo. Logo,

gordura_corporal <- read_csv("dados/brutos/gordura_corporal.csv")

Note que a forma acima, apenas ler e salva os dados na variável gordura_corporal, mas não o exibe. Se é a visualização que se deseja, então, no console, é preciso fazer:

gordura_corporal <- read_csv("dados/brutos/gordura_corporal.csv")
gordura_corporal

Há uma forma que une essas duas etapas: colocar entre parênteses. Assim:

( gordura_corporal <- read_csv("dados/brutos/gordura_corporal.csv") )

Porém, particularmente, uso a função view()⁶, do pacote tibble para “visualizar” a tibble de forma mais ampla e organizada.

gordura_corporal <- read_csv("dados/brutos/gordura_corporal.csv")
view(gordura_corporal)

Ou, usando o operador pipe:

gordura_corporal <- read_csv("dados/brutos/gordura_corporal.csv")

gordura_corporal %>% 
  view()

O script final ficaria assim:

# Carregando o pacote tidyverse
library(tidyverse)

# Lendo e salvando os dados
gordura_corporal <- read_csv("dados/brutos/gordura_corporal.csv")

# Visualizando os dados de forma geral
gordura_corporal %>% view()

E se for uma planilha do Excel?

Para leitura de arquivos no formato .xlsx, usamos um pacote, do tidyverse, denominado: readxl.

A ideia e estrutura são as mesmas, mas o nome da função é read_excel().

Lembre-se de carregar a biblioteca readxl, previamente. Um exemplo de script pode ser visto abaixo:

# Carregando os pacotes
library(tidyverse)
library(readxl)

# Lendo e salvando os dados
nome_adequado <- read_excel("dados/brutos/nome-do-arquivo.xlsx")

# Visualizando o arquivo
nome_adequado %>% view()

Uma outra forma de importar dados

Nem sempre os arquivos são organizados adequadamente numa planilha, causando erros de codificação, erros de leitura, etc.

Por conta disso, aconselho a importação do conjunto de dados, diretamente do R Studio.

Como fazemos isso?

No R Studio, observe o 4º quadrande, ou seja, o nicho dos Files, Plots, Packages, etc;
Selecione a aba Files;
Vá até a pasta onde se encontra o arquivo que você deseja importar;
Clique em tal arquivo;
Selecione Import Dataset...

Abrirá, então, uma janela do R Studio, com uma visualização prévia de seu dataset, onde você poderá verificar se as variáveis estão corretamente relacionadas e, por fim, selecionar o código de incorporação para colá-lo em seu script.

Para exemplificar, vamos considerar um arquivo denominado temperatura_cidades.xlsx que, por hipósete, encontra-se-á no mesmo diretório brutos, da pasta dados.

.
└── tidyverse_readr/
    ├── .gitignore
    ├── dados/
    │   ├── brutos/
    │   │   ├── gordura_corporal.csv
    │   │   └── temperatura_cidades.xlsx
    │   └── tidy
    ├── R/
    └── tidyverse.Rproj

Depois de percorrer o caminho até onde se encontra o arquivo, clicar nele e selecionar Import Dataset..., aparecerá a imagem:

Observe se as variáveis de seu conjunto de dados estão adequadas. Nesse exemplo, a coluna “Ano” e “Mês” estão como variáveis quantitativas (no tidyverse,double - que é o mesmo que numeric, no R Base). Mas, nesse caso, estamos falando de “categorias”, ou “fatores” (de fato, mesmo que representemos pelos números \(1, 2, 3, \ldots\), os meses são “janeiro”, “fevereiro”, etc.) (character). Assim, você poderia mudar a configuração das mesmas.
Copie apenas o necessário. No quadro 2, se você selecionar o ícone que a seta em vermelho aponta, copiará todo o código. Mas, se você já carregou os pacotes anteriormente, não é necessário carregar novamente. Além disso, a função View() é do R Base, você pode desmarcar a opção Open Data Viewer. Então, selecione apenas o que vor adequado.

A figura abaixo mostra a importação depois das mofificações das colunas citadas:

Selecionando o código modificado, temos:

temperatura_cidades <- read_excel(
  "dados/brutos/temperatura_cidades.xlsx", 
  col_types = c("text", "text", "numeric", "numeric", "numeric")
)

Observe que apareceu um novo argumento da função read_excel(), a saber, col_types. Esta, faz as mudanças adequadas nas variáveis escolhidas.

Escrevendo seu dataset

Nem sempre é conveniente trabalhar com um dataset completo, se você só precisará de algumas de suas variáveis. Então, é uma boa prática, depois da limpeza dos dados, criar um arquivo .csv (que é o mais simples e libre de alguns erros de codificação) com exatamente aquilo que você deseja para sua análise.

O pacote readr fornece uma função para isso: a função write_csv(). Ela possui, mais ou menos, a seguinte estrutura:

write_csv(dt, "caminho/novo-nome.csv", arg-1, arg-2, ..., arg-n)

Mais uma vez, os argumentos “arg-1”, “arg-2”, etc., serão, possivelmente, abordados oportunamente depois. Por hora, só necessitamos compreender o argumento “dt” e “novo-nome”.

Ora, dt é o data tibble que você fez a limpeza (ou, pelo menos, selecionou as variáveis para análise); e, "novo-nome.csv" é o novo nome que desejas dar ao arquivo. Neste último caso, deve conter a extensão .csv e estar entre aspas!.

Por exemplo, suponha que o nosso objetivo é escrever o dataset temperatura_cidades.xlsx para o formato .csv. Manteremos o mesmo nome, mas, apenas, modificaremos a extensão. Fica assim:

write_csv(temperatura_cidades, "temperatura_cidades.csv")

Obviamente, essa função será mais explorada quando tratarmos da parte de manipulação de dados, assunto de próximos textos.

                                                    _      
                                                   | |     
                                 _ __ ___  __ _  __| |_ __ 
                                | '__/ _ \/ _` |/ _` | '__|
                                | | |  __/ (_| | (_| | |   
                                |_|  \___|\__,_|\__,_|_|

eu havia pedido para que vocês fizessem isso antes, mas caso não tenham feito, é só colocar no conlose do R Studio: install.packages("usethis")↩︎
Veja que estamos criando a pasta “dados” e, dentro dela, mais duas: “brutos” e “tidy”. A barra / indica o caminho relativo.↩︎
Para esse último exemplo, caso queira usar o usethis novamente, pode fazer assim: usethis::use_directory(c("dados/brutos/csv", "dados/brutos/xlsx"))↩︎
quando o tamanho dos dados for realmente grande, ou seja, mais de 100 Gb, existem procedimentos e pacotes específicos para leitura adequada dos mesmos. Esses procedimentos estão em ascenssão atualmente e fazem parte de uma área chamada “Big Data”↩︎
que dá a porcentagem de gordura corporal para 100 homens, usando variáveis como idade, peso (em libras), altura (em polegadas) e medidas de circunferência (em cm) para o pescoço, peito, abdômen, tornozelo, bíceps e punho. Pode-se usar: 1 libra = 0.45359 kg, bem como, 1 polegada = 2.54 cm↩︎
há uma diferença entre view(), em minúscula; e View(), com primeira letra em maiúscula: a primeira é do pacote tibble e a segunda, do R Base↩︎