Chapter 1 Lidando com dados

Neste Capítulo serão discutidas as tarefas básicas de importação, arrumação, manipulação e exportação de dados usando o R. Serão adotados os princípios do tidy data (dados arrumados). Vamos ver por meio de exemplos as cinco principais ações de manipulação de dados: filtrar, ordenar, selecionar, criar/transformar e resumir. Além disso, tarefas usuais de arrumação de dados como disposição do formato longo para o curto e vice-versa e união de diferentes conjuntos de dados via um código indexador serão discutidas e exemplificadas. Por fim, veremos algumas estratégias e cuidados para lidar com dados perdidos.

Ao trabalhar com análise de dados lidamos com dados de todos os tipos e formatos. O R nativamente apresenta um conjunto completo de ferramentas para importar, manipular e exportar conjuntos de dados. Também existem pacotes especializados para estas tarefas, tais como os pacotes do framework tidyverse: readr para leitura, tidyr para arrumação e o dplyr para manipulação. Neste Capítulo vamos discutir os aspectos básicos da manipulação de dados usando os princípios do tidy data ou dados arrumados. Este termo ficou famoso após o artigo Tidy Data. O chamado tidy data segue três principios:

  • Cada variável está em uma coluna.
  • Cada observação está em uma linha.
  • Cada tipo de unidade observacional está em uma célula.

A Figura 1.1 mostra uma representação de um conjunto de dados em que os 3 princípios do tidy data são atendidos.

Representação dos 3 princípios do tidy data.

Figura 1.1: Representação dos 3 princípios do tidy data.

A ideia parece simples mas na prática pode ser confuso. A melhor forma de entender esses conceitos é por meio da prática e exemplos. Neste Capítulo vamos lidar com conjuntos de dados bem simples para ilustrar os principais aspectos da importação, manipulação e exportação de dados.

A estrutura deste Capítulo segue a ordem lógica de uma análise de dados:

  • Importação de dados: Nesta etapa o objetivo é a partir de uma fonte primária de dados importá-los para o ambiente de programação R. Fontes de dados como o datasus e similares são as mais populares. Em geral os arquivos serão obtidos por meio de algum sítio eletrônico em um formato de texto pleno como .csv, .tsv, .txt entre outros. Outra forma usual é os dados serem disponibilizados em planilhas eletrônicas. Por fim, menos popular é a opção de acessar um banco de dados relacional como MySQL, MariaDB e similares.

  • Arrumação de dados: Após importar a base de dados é comum que ela não esteja organizada como desejamos para análise. Assim, o objetivo desta etapa é fazer com que os três princípios do tidy data sejam respeitados.

  • Manipulação de dados: Com os dados arrumados podemos começar a conhecê-los. Isso envolve uma série de tarefas que podem ser resumidas em: ordenar, selecionar, filtrar, criar/transformar e resumir registros ou observações.

  • Combinação de dados: Em situações mais complexas pode ser necessário lidar com diferentes fontes de dados de forma conjunta. Assim, ter ferramentas para combinar diferentes conjuntos de dados é muito importante.

  • Exportação de dados: Por fim, realizada a análise pode ser de interesse exportar o conjunto de dados organizado ou mesmo diferentes versões com diferentes resumos para serem consumidos por outros aplicativos. Exemplos incluem softwares de visualização de dados e as populares planilhas eletrônicas.

Nas próximas seções cada uma destas etapas será discutida com mais detalhes e diversos exemplos.

1.1 Importando dados

No universo da análise de dados existem diversos tipos de arquivos, tais como: arquivos de texto pleno, planilhas eletrônicas e banco de dados relacionais. Provavelmente, a forma mais popular de armazenar um pequeno conjunto de dados é em uma planilha eletrônica. Todas as planilhas eletrônicas podem facilmente exportar uma tabela no formato retangular em um arquivo de texto pleno (plain text). Para salvar uma planilha em formato texto pleno na maioria das planilhas eletrônicas basta selecionar o Menu -> Arquivo (File) -> Salvar como (Save as) e selecionar o formato desejado. Um cuidado importante é deixar a sua planilha o mais simples possível, ou seja, sem formatações, cores, células mescladas, etc. Lembre-se: cada coluna deve ser uma variável e cada linha uma observação. Entre os diversos formatos disponíveis os mais populares são: .csv (comma-separated value) e .tsv (tab separated values) ou versões destes.

A principal diferença entre esses formatos é o caracter ou estratégia usada para separar as colunas da base de dados. Os nomes são auto-explicativos, por exemplo, no formato .csv as colunas são separadas pelo símbolo , (vírgula). Em português usamos a , para representar decimais, por isso usamos o ; (ponto e vírgula) para separar as colunas. Na prática tanto faz o formato desde que você saiba qual é o caracter ou estratégia usada para delimitar as colunas.

Você pode estar pensando: por que não ler a planilha eletrônica diretamente? Isso é uma possibilidade, porém a extensão das planilhas está atrelada ao sistema operacional. Por exemplo: você não terá planilhas do famoso Microsoft Excel em um sistema operacional Linux. Da mesma forma, você dificilmente terá arquivos do tipo .odf do pacote OpenOffice, popular em ambientes Linux, em sistemas operacionais Windows. Assim, optamos por usar arquivos de texto pleno porque são mais portáveis e, de certa forma, agnósticos ao sistema operacional e/ou software fabricante.

Um arquivo no formato .csv quando visualizado em um editor de texto simples como o bloco de notas, wordpad ou gedit tem o seguinte formato.

Sigla;Código;Município;idh;renda;alfab;
AC;1200013;Acrelândia;;136,539;73,309;
AC;1200054;Assis Brasil;;115,16;70,954;
AC;1200104;Brasiléia;;132,383;75,493;
AC;1200138;Bujari;;118,815;61,23;
AC;1200179;Capixaba;;108,164;62,283;
AC;1200203;Cruzeiro do Sul;;140,199;71,548;
AC;1200252;Epitaciolândia;;134,364;75,381;

Note que o caracter ; separa as colunas. Isso significa que ; é o caracter delimitador de campos. De forma similar um arquivo .tsv tem a seguinte estrutura

circuito    data    rank    corredor    equipe  
Monza   03 September 1950   1   Giuseppe Farina Alfa Romeo
Monza   03 September 1950   2   Dorino Serafini Ferrari
Monza   03 September 1950   2   Alberto Ascari  Ferrari
Monza   03 September 1950   3   Luigi Fagioli   Alfa Romeo
Monza   03 September 1950   4   Louis Rosier    Lago
Monza   03 September 1950   5   Philippe Etancelin  Lago

Neste caso o espaço em branco é quem delimita as colunas. Em R a função read.table() oferece uma forma simples de importar a maioria dos formatos de dados em texto pleno. Além desta função nativa existem pacotes especializados na leitura de dados, tal como o readr.

O objetivo do readr é fornecer uma maneira rápida e amigável de ler dados retangulares. Este pacote foi criado para lidar com os mais diversos tipos de formatos de dados encontrados na prática e dispõe das funções read_csv(), read_tsv(), read_delim(), read_fwf(), read_table() e read_log(). Além de serem funções bastante simples do ponto de vista do usuário, elas possuem um recurso interessante: por meio de um argumento col_types é possível fornecer uma lista que informa já na leitura o tipo da variável, o que poupa esforços na fase de tratamento dos dados para análise. Abaixo carregamos o pacote readr e visualizamos a sua documentação.`

library(readr)
help(readr)

Para leitura do conjunto de dados é importante saber qual é o diretório dentro do computador onde o arquivo de interesse está gravado. Neste Capítulo leremos a base de dados direto de um endereço web. Porém, se não for o seu caso, basta você especificar o caminho do seu arquivo no argumento file. Uma recomendação é deixar o conjunto base de dados no mesmo diretório do seu arquivo .R. Assim, você pode simplesmente fixar o diretório de trabalho como o diretório atual usando a função setwd() e ler o arquivo apenas especificando o nome. Caso você esteja usando o RStudio IDE na Guia Session -> Set Working Directory -> To Source File Location fará está tarefa.

Para começar, vamos importar um arquivo no formato .txt que está no seguinte endereço: http://leg.ufpr.br/~wagner/ms_livro/anovareg.txt. Você pode acessar este endereço e ver que o caracter separador neste exemplo é um tab. Por este motivo usaremos a função do pacote readr destinada a conjuntos de dados separados por tabulação: a read_tsv(). Ao abrir o arquivo .txt nota-se que cada coluna tem um nome, por isso o argumento col_names = TRUE deve ser usado. O Código 1.1 ilustra como importar esta base de dados para o R e mostra as primeiras seis linhas.

Código 1.1 Importando um arquivo do tipo .txt usando a função read_tsv().
library(readr)
url <- "http://leg.ufpr.br/~wagner/ms_livro/anovareg.txt"
dados <- read_tsv(url, col_names = TRUE)
head(dados)
## # A tibble: 6 × 4
##   cultivar  dose bloco indice
##   <chr>    <dbl> <chr>  <dbl>
## 1 Ag-1002      0 I         46
## 2 Ag-1002      0 II        48
## 3 Ag-1002      0 III       44
## 4 Ag-1002      0 IV        46
## 5 Ag-1002     60 I         48
## 6 Ag-1002     60 II        47

Vamos importar um outro conjunto de dados agora no formato .csv que está no seguinte endereço web: http://leg.ufpr.br/~wagner/ms_livro/reglinear.csv. Novamente, você pode abrir o arquivo em um editor de texto e ver que o caracter separador é um espaço em branco. Neste caso a função do pacote readr para leitura é a read_table().

Código 1.2 Importando um arquivo do tipo .csv usando a função read_table().
url <- "http://leg.ufpr.br/~wagner/ms_livro/reglinear.csv"
dados <- read_table(url, col_names = TRUE)
head(dados)
## # A tibble: 6 × 2
##     `"y"` `"x"`
##     <dbl> <dbl>
## 1 207318.    55
## 2 250846.    69
## 3 165755.    46
## 4 219817.    61
## 5 268582.    73
## 6 229060.    63

Se a leitura foi executada com sucesso você não deve receber nenhuma mensagem. O erro mais comum neste ponto é não especificar o caminho de diretórios corretamente, neste caso você vai receber uma mensagem como esta

dados <- read_table("reglinear.csv", col_names = TRUE)
## Error: 'reglinear.csv' does not exist in current working directory ('/home/wagner/Dropbox/My_book/MS_Livro').

O R está dizendo que não conseguiu encontrar o arquivo que você deseja ler no diretório que ele está procurando. Lembre-se: para saber onde o R está trabalhando use o comando getwd().

Com a leitura bem sucedida, é hora de inspecionar o que foi carregado. Recomendamos usar a função glimpse() para ter uma visão geral do arquivo. Assim, vamos carregar o pacote dplyr que contem a função glimpse e inspecionar o objeto dados.

library(dplyr)
glimpse(dados)
## Rows: 20
## Columns: 2
## $ `"y"` <dbl> 207318, 250846, 165755, 219817, 268582, 229060, 179098…
## $ `"x"` <dbl> 55, 69, 46, 61, 73, 63, 50, 46, 69, 62, 63, 60, 55, 70…

A função glimpse() começa mostrando quantas observações (rows) e quantas colunas (cols) a base de dados contém. Neste caso temos \(20\) observações (linhas) e \(2\) variáveis (colunas). Na sequência é apresentado o nome de cada coluna e o tipo de dado que ela representa. Neste exemplo, temos variáveis do tipo dbl que é a abreviação para double. Com o conjunto de dados disponível é o momento de arrumá-los para posterior análise.

1.2 Arrumando dados

Para analisar um conjunto de dados é importante que ele esteja arrumado, ou seja, cada coluna deve ser uma variável e cada linha uma observação. Na maioria das situações práticas os dados não estarão neste formato e você precisará trabalhar para deixá-lo desta forma. Um dos pacotes R mais famosos para arrumação de dados é o tidyr. O Código abaixo carrega o pacote tidyr e acessa sua documentação.

library(tidyr)
help(tidyr)

Uma situação comum é quando os dados vêm em muitas colunas. Este caso ocorre muito na tabulação de dados de experimentos nos quais se tem medidas realizadas ao longo do tempo. Por exemplo,

set.seed(123)
n <- 3
tb1 <- data.frame("cidade" = LETTERS[1:n],
                  US2011 = rpois(n, 4),
                  US2012 = rpois(n, 4),
                  US2013 = rpois(n, 4))

tb1
##   cidade US2011 US2012 US2013
## 1      A      3      6      4
## 2      B      6      7      7
## 3      C      3      1      4

Neste caso temos que as observações da variável de interesse estão em três colunas (US2011, US2012 e US2013). Além disso, a variável US (unidade de saúde), que deveria ser uma única coluna, está no título de três outras colunas. Este é um exemplo típico de dados desorganizados que estão no formato amplo (wide). Nós queremos transformá-los para o formato longo (long), de modo que cada variável esteja em uma coluna e cada observação em uma linha.

Podemos realizar esta operação utilizando o pacote tidyr. Para o caso de empilhar colunas temos a função pivot_longer().

library(magrittr)

tb1_long <- tb1 %>% pivot_longer(names_to = 'US', 
                                 values_to = 'resposta', 
                                 cols = -cidade)

tb1_long
## # A tibble: 9 × 3
##   cidade US     resposta
##   <chr>  <chr>     <int>
## 1 A      US2011        3
## 2 A      US2012        6
## 3 A      US2013        4
## 4 B      US2011        6
## 5 B      US2012        7
## 6 B      US2013        7
## 7 C      US2011        3
## 8 C      US2012        1
## 9 C      US2013        4

A sintaxe é bastante simples:

  • O argumento key nomeia a coluna que vai converter os nomes das colunas para um fator.

  • O argumento value nomeia a coluna que vai receber os valores empilhados das colunas de interesse.

  • Por fim especificamos que nada deve ser feito com a coluna cidade por meio do -cidade.

Outra forma de obter o mesmo resultado com a função pivot_longer() seria especificando que as colunas envolvidas na operação são as colunas US2011, US2012 e US2013. Para isso, no lugar de -cidade, bastaria utilizar alguma destas opções: US2011:US2013, 2:4, c(US2011, US2012, US2013) ou ainda c(2,3,4). Note, basta especificar as colunas que desejamos empilhar.

Note que introduzimos um novo operador: o %>%, chamado de pipe. O objetivo do operador é encaminhar um valor para uma expressão ou chamada de função. Neste caso, utilizamos o %>% para dizer que na função pivot_longer() o objeto de interesse é o nosso data.frame tb1. É importante ressaltar que dentro da função pivot_longer() podemos especificar diretamente o data.frame por meio do argumento data, contudo o código fica mais organizado e elegante quando usamos o %>%.

Podemos também fazer a operação inversa, ou seja, desempilhar caso seja de interesse. Isso pode ser feito com a função pivot_wider() do tidyr.

tb1_long %>% pivot_wider(names_from =  'US', 
                         values_from = 'resposta')
## # A tibble: 3 × 4
##   cidade US2011 US2012 US2013
##   <chr>   <int>  <int>  <int>
## 1 A           3      6      4
## 2 B           6      7      7
## 3 C           3      1      4

Outra operação que pode ser necessária é separar uma variável em várias outras. Isso é comum quando um campo de texto é a união de várias informações. Considere o seguinte data.frame.

tb <- data.frame(US = c("US1", "US2", "US3"),
                 cidade_ano = c("Curitiba/2012", "Santos/2012", "Viçosa/2016"),
                 local = c("Curitiba-PR", "Santos-SP", "Viçosa-MG"))

tb
##    US    cidade_ano       local
## 1 US1 Curitiba/2012 Curitiba-PR
## 2 US2   Santos/2012   Santos-SP
## 3 US3   Viçosa/2016   Viçosa-MG

A coluna cidade_ano é a mistura das variáveis cidade e ano. De forma similar, a coluna local é a mistura de duas variáveis: município e unidade federativa (UF). Assim, precisamos separar estas informações. Note que o caracter / é quem separa as informações na coluna cidade_ano enquanto que na coluna local o caracter - é o separador.

Uma alternativa simples e que exige poucos tratamentos para separação de variáveis é a função separate() do pacote tidyr. Para esta função passamos como argumentos o data.frame, a coluna de interesse, quais colunas novas serão criadas e qual o separador.

tb_nova1 <- tb %>% separate(col = cidade_ano,
                            into = c('Cidade', 'Ano'),
                            sep = '/')

tb_nova1
##    US   Cidade  Ano       local
## 1 US1 Curitiba 2012 Curitiba-PR
## 2 US2   Santos 2012   Santos-SP
## 3 US3   Viçosa 2016   Viçosa-MG
tb_nova2 <- tb_nova1 %>% separate(col = local,
                                  into = c('Município', 'UF'),
                                  sep = '-')

tb_nova2
##    US   Cidade  Ano Município UF
## 1 US1 Curitiba 2012  Curitiba PR
## 2 US2   Santos 2012    Santos SP
## 3 US3   Viçosa 2016    Viçosa MG

Da mesma forma que podemos separar variáveis que estão em uma mesma coluna pode ser necessário criar novas variáveis unindo os valores de duas ou mais colunas. Por exemplo, suponha que em um data.frame os campos dia, mês e ano estão cada um em uma coluna. Porém, você precisa de apenas uma coluna que represente a data da observação. Assim, precisamos juntar essas três colunas em uma nova.

tb <- data.frame(dia = c(1, 5, 23, 16),
                 mes = c(3, 6, 2, 9),
                 ano = 2018)

Esta tarefa pode ser realizada com a função unite() do pacote tidyr em que especifica-se o data.frame, o nome da coluna que receberá a união das outras, o separador de interesse e quais colunas serão unidas. Neste caso, com intuito de manter as variáveis originais acrescentamos o argumento remove = FALSE.

tb <- tb %>% unite(col = 'data',
                   sep = '/',
                   c('dia', 'mes', 'ano'),
                   remove = FALSE)

tb
##        data dia mes  ano
## 1  1/3/2018   1   3 2018
## 2  5/6/2018   5   6 2018
## 3 23/2/2018  23   2 2018
## 4 16/9/2018  16   9 2018

Podemos ainda converter esta coluna para o tipo data.

tb$data <- as.Date(tb$data, format =  "%d/%m/%Y")
tb
##         data dia mes  ano
## 1 2018-03-01   1   3 2018
## 2 2018-06-05   5   6 2018
## 3 2018-02-23  23   2 2018
## 4 2018-09-16  16   9 2018

Por fim, teremos frequentemente que lidar com dados faltantes. Algumas vezes podemos simplesmente querer remover todas as linhas que tenham algum NA. Outras vezes queremos preencher com algum valor específico. O pacote tidyr dispõe de funções bastante úteis para tratamento de dados ausentes. Veja o seguinte conjunto de dados

tb <- data.frame(Paciente = 1:5,
                 N_consultas = c(0, 1, 3, 1, 2),
                 N_tratamentos = c(NA, 0, 0, 2, 1),
                 N_remedios = c(NA, 1, 1, 0, 0))

Para excluir todas as linhas que contenham pelo menos um NA temos a função drop_na() do pacote tidyr.

drop_na(tb)
##   Paciente N_consultas N_tratamentos N_remedios
## 1        2           1             0          1
## 2        3           3             0          1
## 3        4           1             2          0
## 4        5           2             1          0

Para substituir os campos iguais a NA por algum valor o pacote tidyr dispõe da função replace_na(). Esta função recebe como argumento o data.frame e uma lista com o nome da variável no dataframe e que valor um dado ausente encontrado naquela variável deve assumir.

tb %>% replace_na(list(N_tratamentos = 0,
                       N_remedios = 0))
##   Paciente N_consultas N_tratamentos N_remedios
## 1        1           0             0          0
## 2        2           1             0          1
## 3        3           3             0          1
## 4        4           1             2          0
## 5        5           2             1          0

É importante salientar que tratar dados ausentes de forma estatisticamente coerente nem sempre é uma tarefa fácil. Assim, pense muito bem o que os dados faltantes significam no contexto que você está trabalhando e se faz sentido substituir por algum número ou mesmo excluir da base de dados.

1.3 Manipulando dados

Uma vez que os dados estejam arrumados é a hora de começar a conhecê-los. Seguindo os princípios do tidy data para manipular um conjunto de dados temos cinco ações essenciais:

  • Ordenar observações de acordo com os seus valores.

  • Selecionar variáveis de acordo com o seu nome e/ou características.

  • Filtrar observações de acordo com os seus valores.

  • Criar/transformar variáveis a partir de variáveis já existentes.

  • Resumir ou sumarizar dados. Essa ação é a mais complexa e em geral envolve o uso de medidas estatísticas como média, mediana, desvio-padrão entre outros para criar resumo dos dados.

Existem diversas alternativas em R para manipulação de dados. Uma delas é o pacote dplyr. No código abaixo carregamos o pacote dplyr e acessamos a sua documentação.

library(dplyr)
help(dplyr)

Para ilustrar o uso de cada uma das ações de manipulação vamos considerar os dados apresentados na Figura 1.2.O exemplo consiste em um estudo longitudinal compost por sete pacientes de duas unidades de saúde que foram avaliados em três consultas com relação a severidade de alguma doença. A severidade foi avaliado como um nota entre 0 e 10. Por fim, a variável número de medicamentos que o paciente usou durante o período avaliado é registrado na coluna medicamentos. Obviamente este é um exemplo simples e puramente didático. Porém, com base nestes dados é possível ilustrar as principais tarefas da etapa de manipulação de dados.

Uma tabela com dados fictícios sobre um experimento longitudinal.

Figura 1.2: Uma tabela com dados fictícios sobre um experimento longitudinal.

Podemos entrar com esses dados diretamente em R conforme abaixo.

df1 <- data.frame(
    codigo = c(256, 487, 965,
                  125, 458, 874, 963),
    paciente = c("João", "Vanessa", "Tiago",
             "Luana", "Gisele", "Pedro",
             "André"),
    unidade_saude = c("US1", "US1", "US2", "US2",
              "US2", "US1", "US2"),
    severidade1 = c(8, 7.5, 9.5, 7, 4.5, 5.5, 3),
    severidade2 = c(9, 7.5, 8, 8.5, 5, 7.5, NA),
    severidade3 = c(8, 7.5, 7.5, 5, NA, 9, 3),
    medicamentos = c(4, 4, 0, 8, 2, 0, 5))

A ação mais simples é a de ordenação, ilustrada na Figura 1.3. A ordenação pode ser feita de acordo com os valores de uma ou mais variáveis.

Ordenação dos registros de uma tabela.

Figura 1.3: Ordenação dos registros de uma tabela.

Por exemplo, podemos ordenar os pacientes pelo seu código, como ilustrado na Figura 1.3 (linha 1). No dplyr a função destinada para ordenação é a arrange().

df1 %>% arrange(codigo)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    125    Luana           US2         7.0         8.5         5.0
## 2    256     João           US1         8.0         9.0         8.0
## 3    458   Gisele           US2         4.5         5.0          NA
## 4    487  Vanessa           US1         7.5         7.5         7.5
## 5    874    Pedro           US1         5.5         7.5         9.0
## 6    963    André           US2         3.0          NA         3.0
## 7    965    Tiago           US2         9.5         8.0         7.5
##   medicamentos
## 1            8
## 2            4
## 3            2
## 4            4
## 5            0
## 6            5
## 7            0

Note que a variável codigo foi ordenada de forma crescente. Para ordenar de maneira descrescente:

df1 %>% arrange(desc(codigo))
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    965    Tiago           US2         9.5         8.0         7.5
## 2    963    André           US2         3.0          NA         3.0
## 3    874    Pedro           US1         5.5         7.5         9.0
## 4    487  Vanessa           US1         7.5         7.5         7.5
## 5    458   Gisele           US2         4.5         5.0          NA
## 6    256     João           US1         8.0         9.0         8.0
## 7    125    Luana           US2         7.0         8.5         5.0
##   medicamentos
## 1            0
## 2            5
## 3            0
## 4            4
## 5            2
## 6            4
## 7            8

Podemos ordenar por duas ou mais colunas.

df1 %>% arrange(unidade_saude, severidade1)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    874    Pedro           US1         5.5         7.5         9.0
## 2    487  Vanessa           US1         7.5         7.5         7.5
## 3    256     João           US1         8.0         9.0         8.0
## 4    963    André           US2         3.0          NA         3.0
## 5    458   Gisele           US2         4.5         5.0          NA
## 6    125    Luana           US2         7.0         8.5         5.0
## 7    965    Tiago           US2         9.5         8.0         7.5
##   medicamentos
## 1            0
## 2            4
## 3            4
## 4            5
## 5            2
## 6            8
## 7            0

A próxima ação é de seleção e pode ser feita de várias formas:

  • Pelo nome das colunas.
  • Pela posição das linhas ou das colunas.
  • Condicional ao valor de uma ou mais variáveis.
  • Por extremidades cabeça (head) e cauda (tail).

Suponha que temos interesse apenas nas colunas paciente, unidade_saude e medicamentos. Podemos selecionar as colunas pelos seus nomes. Utilizando a função select do dplyr, temos

df1 %>% select(c("paciente", "unidade_saude", "medicamentos"))
##   paciente unidade_saude medicamentos
## 1     João           US1            4
## 2  Vanessa           US1            4
## 3    Tiago           US2            0
## 4    Luana           US2            8
## 5   Gisele           US2            2
## 6    Pedro           US1            0
## 7    André           US2            5

Pelas posições das colunas.

df1 %>% select(c(2,3,7))
##   paciente unidade_saude medicamentos
## 1     João           US1            4
## 2  Vanessa           US1            4
## 3    Tiago           US2            0
## 4    Luana           US2            8
## 5   Gisele           US2            2
## 6    Pedro           US1            0
## 7    André           US2            5

Podemos selecionar apenas os paciente que usam mais de dois medicamentos usando a função filter() do dplyr.

df1 %>% filter(medicamentos > 2 )
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    256     João           US1         8.0         9.0         8.0
## 2    487  Vanessa           US1         7.5         7.5         7.5
## 3    125    Luana           US2         7.0         8.5         5.0
## 4    963    André           US2         3.0          NA         3.0
##   medicamentos
## 1            4
## 2            4
## 3            8
## 4            5

Podemos também selecionar pelo número das linhas usando a função slice() do dplyr.

df1 %>% slice(3:5)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    965    Tiago           US2         9.5         8.0         7.5
## 2    125    Luana           US2         7.0         8.5         5.0
## 3    458   Gisele           US2         4.5         5.0          NA
##   medicamentos
## 1            0
## 2            8
## 3            2

Além disso podemos selecionar apenas as extremidades. Cabeça (head) ou cauda (tail). O número de observações pode ser alterado pelo argumento n.

# Cabeça
df1 %>% slice_head(n = 6)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    256     João           US1         8.0         9.0         8.0
## 2    487  Vanessa           US1         7.5         7.5         7.5
## 3    965    Tiago           US2         9.5         8.0         7.5
## 4    125    Luana           US2         7.0         8.5         5.0
## 5    458   Gisele           US2         4.5         5.0          NA
## 6    874    Pedro           US1         5.5         7.5         9.0
##   medicamentos
## 1            4
## 2            4
## 3            0
## 4            8
## 5            2
## 6            0
# Cauda
df1 %>% slice_tail(n = 6)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    487  Vanessa           US1         7.5         7.5         7.5
## 2    965    Tiago           US2         9.5         8.0         7.5
## 3    125    Luana           US2         7.0         8.5         5.0
## 4    458   Gisele           US2         4.5         5.0          NA
## 5    874    Pedro           US1         5.5         7.5         9.0
## 6    963    André           US2         3.0          NA         3.0
##   medicamentos
## 1            4
## 2            0
## 3            8
## 4            2
## 5            0
## 6            5

Entre as diversas ações possíveis, a de filtrar observações de acordo com suas características é uma das mais importantes. Já vimos a função filter() do dplyr, que permite fazer filtros ou obter subconjuntos que tenham características de interesse. Similar a ação de seleção, a ação de filtro pode ser realizada por uma ou mais características. Por exemplo, podemos selecionar só os pacientes da unidade de saúde US1.

df1 %>% filter(unidade_saude == "US1")
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    256     João           US1         8.0         9.0         8.0
## 2    487  Vanessa           US1         7.5         7.5         7.5
## 3    874    Pedro           US1         5.5         7.5         9.0
##   medicamentos
## 1            4
## 2            4
## 3            0

Outro exemplo é selecionar pacientes em que a soma das severidades das consultas 1, 2 e 3 seja maior que 18.

df1 %>% filter(unidade_saude == "US1" &  (severidade1 + severidade2 + severidade3) > 18)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    256     João           US1         8.0         9.0         8.0
## 2    487  Vanessa           US1         7.5         7.5         7.5
## 3    874    Pedro           US1         5.5         7.5         9.0
##   medicamentos
## 1            4
## 2            4
## 3            0

Pacientes que usam algum medicamento.

df1 %>% filter(medicamentos != 0)
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    256     João           US1         8.0         9.0         8.0
## 2    487  Vanessa           US1         7.5         7.5         7.5
## 3    125    Luana           US2         7.0         8.5         5.0
## 4    458   Gisele           US2         4.5         5.0          NA
## 5    963    André           US2         3.0          NA         3.0
##   medicamentos
## 1            4
## 2            4
## 3            8
## 4            2
## 5            5

Pelo nome dos pacientes.

df1 %>% filter(paciente %in% c("Aline", "Vanessa"))
##   codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1    487  Vanessa           US1         7.5         7.5         7.5
##   medicamentos
## 1            4

O operador %in% implica na seleção de qualquer um que se encaixar em c("Aline", "Vanessa"). Como não temos nenhuma Aline, a saída retornou apenas a linha da paciente Vanessa.

As operações de criar/transformar nos permitem por exemplo renomear as colunas do conjunto de dados. Veja a ilustração da Figura 1.4.

Formas de renomear as colunas de uma tabela.

Figura 1.4: Formas de renomear as colunas de uma tabela.

Para renomear as colunas de um data.frame basta atribuir novos nomes. Para esta tarefa o dplyr possui a função rename().

df1 <- df1 %>% rename(cod = 'codigo',
                      pac = 'paciente',
                      US = 'unidade_saude',
                      s1 = 'severidade1',
                      s2 = 'severidade2',
                      s3 = 'severidade3',
                      med = 'medicamentos')

Trocar a ordem das colunas para que as severidades apareçam primeiro pode ser feito tanto pelo nome como pelos números associados às colunas.

df1[,c(4,5,6,1,2,3)]
##    s1  s2  s3 cod     pac  US
## 1 8.0 9.0 8.0 256    João US1
## 2 7.5 7.5 7.5 487 Vanessa US1
## 3 9.5 8.0 7.5 965   Tiago US2
## 4 7.0 8.5 5.0 125   Luana US2
## 5 4.5 5.0  NA 458  Gisele US2
## 6 5.5 7.5 9.0 874   Pedro US1
## 7 3.0  NA 3.0 963   André US2

A ação de transformação consiste em criar novas variáveis a partir das variáveis existentes. A ideia é ilustrada na Figura 1.5.

Criação e deleção de variáveis em uma tabela.

Figura 1.5: Criação e deleção de variáveis em uma tabela.

Por exemplo, podemos calcular a severidade média dos pacientes. Para isso é possível utilizar a função mutate() do dplyr

df1 %>% mutate(media = (s1 + s2 + s3)/3)
##   cod     pac  US  s1  s2  s3 med media
## 1 256    João US1 8.0 9.0 8.0   4  8.33
## 2 487 Vanessa US1 7.5 7.5 7.5   4  7.50
## 3 965   Tiago US2 9.5 8.0 7.5   0  8.33
## 4 125   Luana US2 7.0 8.5 5.0   8  6.83
## 5 458  Gisele US2 4.5 5.0  NA   2    NA
## 6 874   Pedro US1 5.5 7.5 9.0   0  7.33
## 7 963   André US2 3.0  NA 3.0   5    NA

Note que, onde os pacientes não tem severidade, o cálculo da média resultou em NA. Vamos supor que se o paciente não realizou a consulta a severidade dele será zero.

df1 <- df1 %>% replace_na(list(s1 = 0,
                               s2 = 0,
                               s3 = 0))

df1
##   cod     pac  US  s1  s2  s3 med
## 1 256    João US1 8.0 9.0 8.0   4
## 2 487 Vanessa US1 7.5 7.5 7.5   4
## 3 965   Tiago US2 9.5 8.0 7.5   0
## 4 125   Luana US2 7.0 8.5 5.0   8
## 5 458  Gisele US2 4.5 5.0 0.0   2
## 6 874   Pedro US1 5.5 7.5 9.0   0
## 7 963   André US2 3.0 0.0 3.0   5
df1 <- df1 %>% mutate(media = (s1 + s2 + s3)/3)

df1
##   cod     pac  US  s1  s2  s3 med media
## 1 256    João US1 8.0 9.0 8.0   4  8.33
## 2 487 Vanessa US1 7.5 7.5 7.5   4  7.50
## 3 965   Tiago US2 9.5 8.0 7.5   0  8.33
## 4 125   Luana US2 7.0 8.5 5.0   8  6.83
## 5 458  Gisele US2 4.5 5.0 0.0   2  3.17
## 6 874   Pedro US1 5.5 7.5 9.0   0  7.33
## 7 963   André US2 3.0 0.0 3.0   5  2.00

Podemos criar uma coluna para classificar a severidad. Por exemplo, se o paciente tem severidade (média \(> 7\)) classificamos como alta, como média se (\(40 < \text{média} < 70\)) ou baixa (média \(< 40\)) usando a função cut() temos

breaks <- c(0, 4, 7, 10)

df1$classificacao <- cut(df1$media, 
                    breaks = breaks, 
                    labels = c("Baixa", "Média", "Alta"))
df1
##   cod     pac  US  s1  s2  s3 med media classificacao
## 1 256    João US1 8.0 9.0 8.0   4  8.33          Alta
## 2 487 Vanessa US1 7.5 7.5 7.5   4  7.50          Alta
## 3 965   Tiago US2 9.5 8.0 7.5   0  8.33          Alta
## 4 125   Luana US2 7.0 8.5 5.0   8  6.83         Média
## 5 458  Gisele US2 4.5 5.0 0.0   2  3.17         Baixa
## 6 874   Pedro US1 5.5 7.5 9.0   0  7.33          Alta
## 7 963   André US2 3.0 0.0 3.0   5  2.00         Baixa

A última ação que vamos discutir é a de resumo ou sumarização. Esta ação está muito ligada com a ideia de dados no formato amplo. No exemplo dos pacientes o conjunto de dados está no formato amplo. Se desejarmos calcular a média da severidade para cada consulta precisamos percorrer as colunas severidade1, severidade2 e severidade3 uma a uma calculando a média. Se os dados estiverem no formato longo poderíamos mais facilmente usar a ideia de resumir uma variável condicional aos valores de uma outra, neste caso: a severidade. A Figura 1.6 ilustra como é o processo de tornar um conjunto de dados do formato amplo para o longo ou empilhado.

Modificação da disposição com empilhamento.

Figura 1.6: Modificação da disposição com empilhamento.

Usando a função pivot_longer() podemos facilmente passar um conjunto de dados do formato amplo para longo. Note que vamos remover as colunas cod, rem``,mediaeclassificacao` antes de fazer a manipulação.

df1_temp <- df1 %>% select(-c(cod, med, media, classificacao))

df1_long <- df1_temp %>% pivot_longer(names_to = 'consulta', 
                                      values_to = 'valor', 
                                      cols = -c(pac, US))

df1_long
## # A tibble: 21 × 4
##    pac     US    consulta valor
##    <chr>   <chr> <chr>    <dbl>
##  1 João    US1   s1         8  
##  2 João    US1   s2         9  
##  3 João    US1   s3         8  
##  4 Vanessa US1   s1         7.5
##  5 Vanessa US1   s2         7.5
##  6 Vanessa US1   s3         7.5
##  7 Tiago   US2   s1         9.5
##  8 Tiago   US2   s2         8  
##  9 Tiago   US2   s3         7.5
## 10 Luana   US2   s1         7  
## # … with 11 more rows

Agora suponha que queremos saber qual é a nota média por consulta. Estamos fazendo um resumo da coluna valor porém de acordo com os valores da coluna consulta. Informalmente, dizemos que estamos agrupando pela coluna consulta ou fazendo um group by por consulta. Este resultado pode ser obtido por meio da função summarise() do dplyr

df1_long %>% 
    group_by(consulta) %>% 
    summarise(media = mean(valor))
## # A tibble: 3 × 2
##   consulta media
##   <chr>    <dbl>
## 1 s1        6.43
## 2 s2        6.5 
## 3 s3        5.71

Podemos agrupar por mais de uma coluna. Por exemplo, a severidade média de cada unidade de saúde para cada consulta.

df1_long %>%
    group_by(US, consulta) %>% 
    summarise(media = mean(valor))
## # A tibble: 6 × 3
## # Groups:   US [2]
##   US    consulta media
##   <chr> <chr>    <dbl>
## 1 US1   s1        7   
## 2 US1   s2        8   
## 3 US1   s3        8.17
## 4 US2   s1        6   
## 5 US2   s2        5.38
## 6 US2   s3        3.88

Outra opção é calcular mais do que uma medida resumo. No caso da função summarise() basta acrescentar uma linha especificando que temos interesse em obter outra medida.

df1_long %>% 
    group_by(US, consulta) %>% 
    summarise(media = mean(valor),
              sd = sd(valor))
## # A tibble: 6 × 4
## # Groups:   US [2]
##   US    consulta media    sd
##   <chr> <chr>    <dbl> <dbl>
## 1 US1   s1        7    1.32 
## 2 US1   s2        8    0.866
## 3 US1   s3        8.17 0.764
## 4 US2   s1        6    2.86 
## 5 US2   s2        5.38 3.90 
## 6 US2   s3        3.88 3.17

Este tipo de tarefa é também chamada de split-apply-combine. A Figura 1.7 mostra em detalhes o que foi realizado.

Agregação de uma tabela.

Figura 1.7: Agregação de uma tabela.

Primeiro nós dividimos (split) o conjunto de dados pelas variáveis unidade de saúde e consulta. Para cada pedaço foram calculadas as medidas resumo (apply). Finalmente, combinamos os resultados em um novo data.frame (combine).

1.4 Combinando dados

Em algumas situações pode ser necessário combinar diversos conjuntos de dados. A situação mais comum é quando você já tem um conjunto de dados, como por exemplo o nosso df1, e um novo conjunto de dados chega. Assim, precisamos combinar os dados que já temos com o novo. Suponha que o novo conjunto de dados é o seguinte.

df2 <- data.frame(
    codigo = c(505, 658, 713),
    paciente = c("Bia", "Carlos", "Cris"),
    unidade_saude = c("US3", "US3", "US3"),
    severidade1 = c(6.5, 7.5, 7.5),
    severidade2 = c(8.5, 8.0, 9.0),
    medicamentos = c(0, 0, 2))

Para combinar o novo conjunto de dados com o antigo a primeira coisa a fazer é deixá-los compatíveis. Isso significa que devem ter os mesmos dados e as colunas devem ter os mesmos nomes. Como fizemos diversos cálculos com o df1, vamos recriá-lo.

df1 <- data.frame(
    codigo = c(256, 487, 965,
                  125, 458, 874, 963),
    paciente = c("João", "Vanessa", "Tiago",
             "Luana", "Gisele", "Pedro",
             "André"),
    unidade_saude = c("US1", "US1", "US2", "US2",
              "US2", "US1", "US2"),
    severidade1 = c(8, 7.5, 9.5, 7, 4.5, 5.5, 3),
    severidade2 = c(9, 7.5, 8, 8.5, 5, 7.5, NA),
    severidade3 = c(8, 7.5, 7.5, 5, NA, 9, 3),
    medicamentos = c(4, 4, 0, 8, 2, 0, 5))

Note que no conjunto df2 não temos uma coluna chamada de severidade3. Assim, primeiro precisamos criar esta coluna.

df2$severidade3 <- NA

Uma vez que os conjuntos de dados são compatíveis, podemos simplesmente concatenar suas linhas usando a função rbind().

df <- rbind(df1, df2)
df
##    codigo paciente unidade_saude severidade1 severidade2 severidade3
## 1     256     João           US1         8.0         9.0         8.0
## 2     487  Vanessa           US1         7.5         7.5         7.5
## 3     965    Tiago           US2         9.5         8.0         7.5
## 4     125    Luana           US2         7.0         8.5         5.0
## 5     458   Gisele           US2         4.5         5.0          NA
## 6     874    Pedro           US1         5.5         7.5         9.0
## 7     963    André           US2         3.0          NA         3.0
## 8     505      Bia           US3         6.5         8.5          NA
## 9     658   Carlos           US3         7.5         8.0          NA
## 10    713     Cris           US3         7.5         9.0          NA
##    medicamentos
## 1             4
## 2             4
## 3             0
## 4             8
## 5             2
## 6             0
## 7             5
## 8             0
## 9             0
## 10            2

Figura 1.8 ilustra a operação realizada.

Concatenação de duas tabelas.

Figura 1.8: Concatenação de duas tabelas.

Por fim, uma outra operação que aparece com frequência ao analisar dados é a de juntar/parear duas tabelas que possuem uma chave primária. Essas operações são geralmente chamadas de junções ( join ) e existem diversas versões, as mais comuns são:

  • Junção por interseção (inner join).
  • Junção por união (full join).
  • Junção à esquerda (left join).
  • Junção à direita (right join).
  • Existem também os chamados exclusive joins.

Cada uma destas versões são ilustradas na Figura 1.10.

Tipos de junções de tabelas ilustrado com diagramas de Veen.

Figura 1.9: Tipos de junções de tabelas ilustrado com diagramas de Veen.

Para praticarmos este tipo de operação considere o seguinte conjunto de dados.

df_extra <- data.frame(
    "codigo" = c(256, 965, 285, 125, 874, 321, 669, 963),
    "paciente" = c("João", "Tiago", "Tiago", "Luana", 
               "Pedro", "Mia", "Luana", "André"),
    "idade" = c(18, 18, 22, 21, 19, 18, 19, 20),
    "assist_social" = c("S", "N", "N", "S", "N", "N", "S", "N"))

O pacote dplyr() possui funções específicas para cada tipo de junção

# Left join
left_join(df1, df_extra, by = "codigo")

# Right join
right_join(df1, df_extra, by = "codigo")

# inner join
inner_join(df1, df_extra, by = "codigo")

# full join
full_join(df1, df_extra, by = "codigo")

A diferença entre os diferentes join é bastante simples:

  • left join: mantém todos os registros da tabela a esquerda (df1) e completa com os correspondentes da tabela da direita (df_extra).

  • right join: mantém todos os registros da tabela da direita (df_extra) e completa com os dados da tabela da esquerda (df1).

  • inner join: mantém apenas os registros que estão em ambas tabelas.

  • full join: mantém todos os registros e preenche com NA onde não tem correspondência entre as tabelas.

Figura 1.10 ilustra os diferentes tipos de join para um subconjunto dos dados discutidos neste Capítulo.

Junções de tabelas do tipo inclusivas.

Figura 1.10: Junções de tabelas do tipo inclusivas.

1.5 Exportando dados

Após realizar as análises é bastante provável que você precise exportar um conjunto de dados organizado ou mesmo uma tabela com estatísticas. O R tem uma longa lista de funções para exportar dados. Assim como leitura, o pacote readr dispõe de uma série de funções de escrita.

A forma mais comum é exportar um arquivo de texto pleno nos formatos .csv ou .txt. Para esta tarefa as funções write_tsv() e write_csv() podem ser usadas. Podemos exportar o resultado da junção das tabelas df1 e df_extra como o resultado final de nossa análise, conforme ilustra o Código 1.3.

Código 1.3 Exemplo de uso da função write_csv() para exportar arquivos de texto pleno.
final <- inner_join(df1, 
                    df_extra, 
                    by = "matricula")

write_csv(final, 
          file = "Nome_do_arquivo.csv")

Os argumentos básicos são o data.frame que você quer salvar em disco e o nome desejado. A maioria dos argumentos de escrita são iguais ou muito similares aos argumentos de leitura. Assim, exportação de dados não gera mais complexidade e tudo que você já aprendeu para leitura se aplica imediatamente.

Sem dúvida, exportar dados em texto pleno é muito fácil e simples. No entanto, existem algumas desvantagens. A principal é que as classes das colunas podem ser perdidas ao ler novamente o conjunto de dados em R. Por ser um texto pleno o arquivo não carrega metadados que foram criados em R. Caso seja de interesse, é possível salvar o próprio objeto R que contém o seu data.frame usando a função save().

save(final, 
     file = "Nome_do_arquivo.RData")

A principal vantagem é que tudo que você fez no objeto final será mantido. Outra vantagem é que você pode salvar outros formatos de dados como listas, matrizes e arrays. Para carregar novamente o data.frame você deve usar a função load().

load("Nome_do_arquivo.RData")

Caso você tenha um objeto mais complicado, como por exemplo uma série de listas, a função dput() é uma opção interessante. Ela permite salvar um objeto R como um texto simples que pode ser copiado e colado.

dput(final)

É possível também escrever um arquivo com extensão .R que pode ser posteriormente carregado no R.

dput(final, 
     file = "Nome_do_arquivo.R")

Para carregar os dados basta usar a função dget().

dget("Nome_do_arquivo.R")

Essa estratégia pode ser usada para múltiplos objetos usando a função dump().

dump(c("final", "df1"), 
     file = "Nome_do_arquivo.R")

Que agora deve ser carregado em R usando a função source().

source("Nome_do_arquivo.R")

Um outro formato que o R exporta é o formato binário com a extensão .rda. As vantagens deste formato são que ocupa pouco espaço em disco e preserva as propriedades do objeto R.

save(final, 
     file = "Nome_do_arquivo.rda")

Neste caso, podemos usar novamente a função load() para fazer a leitura em R.

Por fim, você pode salvar todos os objetos e instruções que você usou em sua sessão R usando a função save.image().

Lembre-se: sempre que você não especificar o caminho de escrita explicitamente, o R vai escrever no diretório de trabalho atual. Algumas funções úteis para você ter controle de onde o R está escrevendo os arquivos são:

  • file.info(): mostra o tamanho do arquivo, data de criação e outros detalhes do arquivo.
  • dir(): mostra todos os arquivos presentes em um diretório.
  • file.exists(): verifica se um arquivo já existe (TRUE) ou não (FALSE) no diretório de trabalho.
  • getwd() e setwd(): verifica e altera o diretório de trabalho, respectivamente.

Neste Capítulo foram vistas as principais operações com dados tabulares usando os principios do tidy data e os pacotes do tidyverse.