Skip to main content

Software R para avaliação de dados experimentais: Um foco em experimentos agronômicos

Capítulo 7 Manipulação de dados

Após seus dados estarem carregados no ambiente R, eles provavelmente necessitarão de alguma manimulação antes de serem utilizados em uma determinada análise. Esta manipulação pode envolver operações como exclusão de colunas, ordenamento de linhas com base em valores, criação de covariáveis (que serão resultado de operações com uma ou mais variáveis existentes), dentre muitas outras possibilidades. Felizmente, o pacote dplyr permite que esta manimulação seja relativamente fácil, lógica (do ponto de vista de digitação de códigos) e rápida, pois ele integra a linguagem C++ em suas funções.

O pacote dplyr é uma gramática de manipulação de dados. Nos rerferimos à gramática aqui porque ele fornece funções nomeadas como verbos simples, relacionados às tarefas mais comuns de manipulação de dados, para ajudá-lo a traduzir seus pensamentos em código. Este será o pacote utilizado para manipulação dos dados no decorrer deste material. De fato, a maioria dos dados em R podem ser manipulados utilizando os seguintes “verbos”.

Anteriomente mencionamos que a manipulação dos dados com o pacote dplyr é lógica do ponto de vista da implementação do código. Isto só é possivel devido a utilização do operador %>% (forward-pipe operator), importado do pacote magrittr. Basicamente, este operador capta o argumento resultante de uma função à sua esquerda e passa como input à função à sua direita. Não é nossso objetivo aqui discutir os benefícios da utilização deste operador, mas uma pequena demonstração (com spoilers das funções do pacote dplyr) será apresentada. Considere as seguintes (e simples) operações. Crie um data frame com 100 linhas com as variáveis x e y contendo valores aleatórios. Adicione uma terceira variáveis (z) que será uma função da multiplicação de x e y, selecione apenas os valores de z menores que 10 e extraia a raiz quadrada destes valores. Finalmente, compute a média e armazene no object mean_sqrt.

  • Criando o conjunto de dados
library(tidyverse)
library(metan)
set.seed(1)
data <- tibble(x = runif(100, 0, 10),
               y = runif(100, 0, 10))
  • Utilizando as funções bases do R (código massivo)
data$z <- data$x * data$y
df <- subset(data, z < 10)
df <- df[, 3]
sqr_dat <- sqrt(df$z)
mean_sqrt <- mean(sqr_dat)
mean_sqrt
# [1] 1.977507
  • Utilizando as funções bases do R (código mais limpo)
data$z <- data$x * data$y
mean_sqrt <- mean(sqrt(subset(data, z < 10)$z))
mean_sqrt
# [1] 1.977507
  • Utilizando o operdor %>% 
mean_sqrt <- 
  data %>% 
  mutate(z = x * y) %>%
  filter(z < 10) %>%
  pull(z) %>%
  sqrt() %>%
  mean()
mean_sqrt
# [1] 1.977507

A utilização do operador %>% parece não trazer tantos benefícios neste exemplo, visto que objetivo aqui foi demonstrar como ele permite uma implementação lógica das operações realizadas, captando a saída da função diretamente à esquerda (acima neste caso) e passando para a próxima função. Em operações mais complexas, no entanto, o %>% se mostrará muito mais útil.

O pacote metan fornece funções úteis para manipulação de dados. Duas principais categorias de funções serão utilizadas neste material:

  1. Utilitários para lidar com linhas e colunas
  • add_cols(): adiciona uma ou mais colunas a um conjunto de dados existente. Se as colunas .before ou .after especificadas não existirem, as colunas serão anexadas no final dos dados. Retorna um conjunto de dados com todas as colunas originais em .data mais as colunas declaradas em .... Em add_cols(), as colunas em .data estão disponíveis para as expressões. Portanto, é possível adicionar uma coluna com base nos dados existentes.
  • add_rows(): adiciona uma ou mais linhas a um conjunto de dados existente. Se não houver linhas especificadas .before ou .after, as linhas serão anexadas no final dos dados. Retorna um conjunto de dados com todas as linhas originais em .data mais as linhas declaradas em ....
  • add_prefix() e add_suffix(): adicionam prefixos e sufixos, respectivamente, nos nomes das variáveis selecionadas.
  • all_pairs(): obtém todos os pares possíveis entre os níveis de um fator.
  • colnames_to_lower(): converte todos os nomes de coluna para minúsculas.
  • colnames_to_upper(): converte todos os nomes de coluna para maiúsculas.
  • colnames_to_title(): converte todos os nomes de coluna em maiúsculas.
  • column_exists(): verifica se existe uma coluna em um conjunto de dados. Retorne um valor lógico.
  • columns_to_first(): move as colunas para as primeiras posições em .data.
  • columns_to_last(): move as colunas para as últimas posições em .data.
  • concatenate(): concatena colunas de um conjunto de dados.
  • get_levels(): obtém os níveis de um fator.
  • get_level_size(): obtém o tamanho de cada nível de um fator.
  • remove_cols(): remove uma ou mais colunas de um conjunto de dados.
  • remove_rows(): remove uma ou mais linhas de um conjunto de dados.
  • reorder_cols(): reordena colunas em um conjunto de dados.
  • select_cols(): seleciona uma ou mais colunas de um conjunto de dados.
  • select_first_col(): seleciona a primeira variável, possivelmente com um deslocamento.
  • select_last_col(): seleciona a última variável, possivelmente com um deslocamento.
  • select_numeric_cols(): selecione todas as colunas numéricas de um conjunto de dados.
  • select_non_numeric_cols(): seleciona todas as colunas não numéricas de um conjunto de dados.
  • select_rows(): seleciona uma ou mais linhas de um conjunto de dados.
  1. Utilitários para lidar com números e strings
  • all_lower_case(): converte todas as sequências não numéricas de um conjunto de dados para minúsculas (“Env” para “env”).
  • all_upper_case(): converte todas as sequências não numéricas de um conjunto de dados para maiúsculas (por exemplo, “Env” para “ENV”).
  • all_title_case(): converta todas as sequências não numéricas de um conjunto de dados em maiúsculas e minúsculas (por exemplo, “ENV” para “Env”).
  • extract_number(): extrai o(s) número(s) de uma sequência de caracteres.
  • extract_string(): Extrai todas letras de uma sequência de caracteres, ignorando maiúsculas e minúsculas.
  • find_text_in_num(): encontra caracteres de texto em uma sequência numérica e retorna o índice de linha.
  • has_text_in_num(): inspeciona as colunas procurando por texto na sequência numérica e retorna um aviso se algum texto for encontrado.
  • remove_strings(): remove todas as strings de uma variável.
  • replace_number(): substitui os números por uma substituição.
  • replace_string(): substitui todas as strings por uma substituição, ignorando a caixa.
  • round_cols(): Arredonda uma coluna selecionada ou um conjunto de dados inteiro para números significativos.
  • tidy_strings(): arruma seqüências de caracteres, colunas não numéricas ou quaisquer colunas selecionadas em um conjunto de dados colocando todas as palavras em maiúsculas, substituindo qualquer espaço, tabulação e caracteres de pontuação por '_' e colocando '_' entre letras maiúsculas e minúsculas. Suponha que str = c("Env1", "env 1", "env.1") (que por definição deve representar um nível único nos ensaios de melhoramento de plantas, por exemplo, ambiente 1) seja submetido a tidy_strings(str): o resultado será então c("ENV_1", "ENV_1", "ENV_1").

O conjunto de dados maize será utilizado como exemplo para as operações de manipulação de dados. Este arquivo em formato .xlsx está hospedado em https://github.com/TiagoOlivoto/e-bookr/tree/master/data e pode ser carregado no ambiente R com a função import() do pacote rio.

library(rio)
url <- "https://github.com/TiagoOlivoto/e-bookr/raw/master/data/data_R.xlsx"
maize <- import(url,
                sheet = "maize", 
                setclass = "tibble")
inspect(maize)
# # A tibble: 10 x 9
#    Variable Class     Missing Levels Valid_n   Min Median    Max Outlier
#    <chr>    <chr>     <chr>   <chr>    <int> <dbl>  <dbl>  <dbl>   <dbl>
#  1 AMB      character No      0          780  NA    NA     NA         NA
#  2 HIB      character No      0          780  NA    NA     NA         NA
#  3 REP      character No      0          780  NA    NA     NA         NA
#  4 APLA     numeric   No      -          780   1     2.52   3.3        4
#  5 AIES     numeric   No      -          780   0.5   1.38   2.39       1
#  6 CESP     numeric   No      -          780   0.8  15.4   20.4       16
#  7 DIES     numeric   No      -          780  36.4  50.0   59.7        1
#  8 MGRA     numeric   No      -          780  58.5 174.   291.         0
#  9 MMG      numeric   No      -          780 123.  344.   546.         6
# 10 NGRA     numeric   No      -          780 147   517    903          9

7.1 Trabalhando com linhas e colunas

7.1.1 Selecionar colunas

A função select_cols() pode ser usada para selecionar colunas de um conjunto de dados.

select_cols(maize, AMB, HIB)
# # A tibble: 780 x 2
#    AMB   HIB  
#    <chr> <chr>
#  1 A1    H1   
#  2 A1    H1   
#  3 A1    H1   
#  4 A1    H1   
#  5 A1    H1   
#  6 A1    H1   
#  7 A1    H1   
#  8 A1    H1   
#  9 A1    H1   
# 10 A1    H1   
# # ... with 770 more rows

As colunas numéricas podem ser selecionadas rapidamente usando a função select_numeric_cols(). As colunas não numéricas são selecionadas com select_non_numeric_cols().

select_numeric_cols(maize)
# # A tibble: 780 x 7
#     APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1  2.45  2.39  16.9  52.1 228.   375.   609
#  2  2.5   1.43  14.4  50.7 187.   437.   427
#  3  2.69  1.52  16.5  54.7 230.   464.   497
#  4  2.8   1.64  16.8  52.0 213.   408.   523
#  5  2.62  1.55  15.9  51.6 224.   406.   551
#  6  2.12  1.8   15    51.4 203.   383.   529
#  7  3.15  1.78  10.9  41.9  75.2  256.   294
#  8  2.97  1.84  15    53.4 204.   387.   528
#  9  3.1   1.78  13.6  50.8 187.   348.   538
# 10  3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows
select_non_numeric_cols(maize)
# # A tibble: 780 x 3
#    AMB   HIB   REP  
#    <chr> <chr> <chr>
#  1 A1    H1    I    
#  2 A1    H1    I    
#  3 A1    H1    I    
#  4 A1    H1    I    
#  5 A1    H1    I    
#  6 A1    H1    II   
#  7 A1    H1    II   
#  8 A1    H1    II   
#  9 A1    H1    II   
# 10 A1    H1    II   
# # ... with 770 more rows

Podemos selecionar a primeira ou a última coluna rapidamente com select_first_col() e select_last_col(), respectivamente.

select_first_col(maize)
# # A tibble: 780 x 1
#    AMB  
#    <chr>
#  1 A1   
#  2 A1   
#  3 A1   
#  4 A1   
#  5 A1   
#  6 A1   
#  7 A1   
#  8 A1   
#  9 A1   
# 10 A1   
# # ... with 770 more rows
select_last_col(maize)
# # A tibble: 780 x 1
#     NGRA
#    <dbl>
#  1   609
#  2   427
#  3   497
#  4   523
#  5   551
#  6   529
#  7   294
#  8   528
#  9   538
# 10   582
# # ... with 770 more rows

Select helpers podem ser usados para selecionar variáveis que correspondem a uma expressão. Isso significa que podemos usar uma função para selecionar variáveis em vez de digitar seus próprios nomes. O metan reexporta os tidy select helpers e implementa os próprios select helpers com base em operações com prefixos e sufixos (different_var(), intersect_var() e union_var()), tamanho dos nomes das variáveis (width_of(), width_gength_than() e width_less_than()) e no tipo de letra (lower_case_only(), upper_case_only() e title_case_only()).

  • Selecionando variáveis que começam com um prefixo.

Se quisermos selecionar as variáveis que começam com “C”, podemos usar:

select_cols(maize, starts_with("C"))
# # A tibble: 780 x 1
#     CESP
#    <dbl>
#  1  16.9
#  2  14.4
#  3  16.5
#  4  16.8
#  5  15.9
#  6  15  
#  7  10.9
#  8  15  
#  9  13.6
# 10  16.3
# # ... with 770 more rows

mas se quisermos selecionar aqueles que não começam com “C”, basta adicionar “-” logo antes de starts_with()

select_cols(maize, -starts_with("C"))
# # A tibble: 780 x 9
#    AMB   HIB   REP    APLA  AIES  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I      2.45  2.39  52.1 228.   375.   609
#  2 A1    H1    I      2.5   1.43  50.7 187.   437.   427
#  3 A1    H1    I      2.69  1.52  54.7 230.   464.   497
#  4 A1    H1    I      2.8   1.64  52.0 213.   408.   523
#  5 A1    H1    I      2.62  1.55  51.6 224.   406.   551
#  6 A1    H1    II     2.12  1.8   51.4 203.   383.   529
#  7 A1    H1    II     3.15  1.78  41.9  75.2  256.   294
#  8 A1    H1    II     2.97  1.84  53.4 204.   387.   528
#  9 A1    H1    II     3.1   1.78  50.8 187.   348.   538
# 10 A1    H1    II     3.02  1.6   53.9 250.   430.   582
# # ... with 770 more rows
  • Selecionando variáveis que terminam com um sufixo.

Da mesma forma, se quisermos selecionar as variáveis que terminam com “S”, podemos usar:

select_cols(maize, ends_with("S"))
# # A tibble: 780 x 2
#     AIES  DIES
#    <dbl> <dbl>
#  1  2.39  52.1
#  2  1.43  50.7
#  3  1.52  54.7
#  4  1.64  52.0
#  5  1.55  51.6
#  6  1.8   51.4
#  7  1.78  41.9
#  8  1.84  53.4
#  9  1.78  50.8
# 10  1.6   53.9
# # ... with 770 more rows
  • Selecionando variáveis que começam com um prefixo A E terminam com um sufixo “S”

Agora, se quisermos selecionar variáveis que começam com “A” e terminam com “S”, ou seja, a interseção entre a letra inicial “A” e a letra final “S”, podemos:

select_cols(maize, intersect_var("A", "S"))
# # A tibble: 780 x 1
#     AIES
#    <dbl>
#  1  2.39
#  2  1.43
#  3  1.52
#  4  1.64
#  5  1.55
#  6  1.8 
#  7  1.78
#  8  1.84
#  9  1.78
# 10  1.6 
# # ... with 770 more rows
  • Selecionando variáveis que começam com um prefixo OU terminam com um sufixo.

Também podemos obter a união entre a letra inicial “A” e a letra final “S”, ou seja, variáveis que começam com “A” ou terminam com “S”.

select_cols(maize, union_var("A", "S"))
# # A tibble: 780 x 4
#    AMB    APLA  AIES  DIES
#    <chr> <dbl> <dbl> <dbl>
#  1 A1     2.45  2.39  52.1
#  2 A1     2.5   1.43  50.7
#  3 A1     2.69  1.52  54.7
#  4 A1     2.8   1.64  52.0
#  5 A1     2.62  1.55  51.6
#  6 A1     2.12  1.8   51.4
#  7 A1     3.15  1.78  41.9
#  8 A1     2.97  1.84  53.4
#  9 A1     3.1   1.78  50.8
# 10 A1     3.02  1.6   53.9
# # ... with 770 more rows
  • Selecionando variáveis que começam com um prefixo E NÃO terminam com um sufixo.

Também podemos obter a diferença entre a letra inicial “A” e a letra final “S”, ou seja, variáveis que começam com “C” e não terminam com “D”.

select_cols(maize, difference_var("A", "S"))
# # A tibble: 780 x 2
#    AMB    APLA
#    <chr> <dbl>
#  1 A1     2.45
#  2 A1     2.5 
#  3 A1     2.69
#  4 A1     2.8 
#  5 A1     2.62
#  6 A1     2.12
#  7 A1     3.15
#  8 A1     2.97
#  9 A1     3.1 
# 10 A1     3.02
# # ... with 770 more rows
  • Selecionando variáveis que contêm uma string literal.

Se as variáveis no conjunto de dados tiverem um padrão com diferenças entre um grupo de variáveis, podemos usar o código a seguir para selecionar variáveis com um padrão. Primeiro, iremos alterar os nomes das variáveis PH, EH, EP e EL incluindo _PLANT para indicar que são variáveis relacionadas à planta. Em seguida, selecionaremos essas variáveis com a função contains().

data_vars <- 
  maize %>%
  rename(APLA_PLANT = APLA,
         AIES_PLANT = AIES)
names(data_vars)
#  [1] "AMB"        "HIB"        "REP"        "APLA_PLANT" "AIES_PLANT"
#  [6] "CESP"       "DIES"       "MGRA"       "MMG"        "NGRA"

select_cols(data_vars, contains("PLANT"))
# # A tibble: 780 x 2
#    APLA_PLANT AIES_PLANT
#         <dbl>      <dbl>
#  1       2.45       2.39
#  2       2.5        1.43
#  3       2.69       1.52
#  4       2.8        1.64
#  5       2.62       1.55
#  6       2.12       1.8 
#  7       3.15       1.78
#  8       2.97       1.84
#  9       3.1        1.78
# 10       3.02       1.6 
# # ... with 770 more rows
  • Selecionando variáveis que correspondem a uma expressão regular.

Seleções mais sofisticadas podem ser feitas usando matches(). Supondo que gostaríamos de selecionar as variáveis que começam com “A” e tem a segunda letra entre “A” e “M”, usaríamos algo como:

select_cols(maize, matches("^A[A-M]"))
# # A tibble: 780 x 2
#    AMB    AIES
#    <chr> <dbl>
#  1 A1     2.39
#  2 A1     1.43
#  3 A1     1.52
#  4 A1     1.64
#  5 A1     1.55
#  6 A1     1.8 
#  7 A1     1.78
#  8 A1     1.84
#  9 A1     1.78
# 10 A1     1.6 
# # ... with 770 more rows
  • Selecionando a última ou a primeira variável, possivelmente com um deslocamento.

Podemos selecionar a n-ésima primeira ou a última coluna com select_last_col() ou select_first_col().

select_first_col(data_vars)
# # A tibble: 780 x 1
#    AMB  
#    <chr>
#  1 A1   
#  2 A1   
#  3 A1   
#  4 A1   
#  5 A1   
#  6 A1   
#  7 A1   
#  8 A1   
#  9 A1   
# 10 A1   
# # ... with 770 more rows
select_last_col(data_vars)
# # A tibble: 780 x 1
#     NGRA
#    <dbl>
#  1   609
#  2   427
#  3   497
#  4   523
#  5   551
#  6   529
#  7   294
#  8   528
#  9   538
# 10   582
# # ... with 770 more rows
  • Selecione variáveis com um comprimento de nome específico (quatro letras)
select_cols(data_vars, width_of(4))
# # A tibble: 780 x 4
#     CESP  DIES  MGRA  NGRA
#    <dbl> <dbl> <dbl> <dbl>
#  1  16.9  52.1 228.    609
#  2  14.4  50.7 187.    427
#  3  16.5  54.7 230.    497
#  4  16.8  52.0 213.    523
#  5  15.9  51.6 224.    551
#  6  15    51.4 203.    529
#  7  10.9  41.9  75.2   294
#  8  15    53.4 204.    528
#  9  13.6  50.8 187.    538
# 10  16.3  53.9 250.    582
# # ... with 770 more rows
  • Selecione variáveis com largura menor que n.
select_cols(data_vars, width_less_than(4))
# # A tibble: 780 x 4
#    AMB   HIB   REP     MMG
#    <chr> <chr> <chr> <dbl>
#  1 A1    H1    I      375.
#  2 A1    H1    I      437.
#  3 A1    H1    I      464.
#  4 A1    H1    I      408.
#  5 A1    H1    I      406.
#  6 A1    H1    II     383.
#  7 A1    H1    II     256.
#  8 A1    H1    II     387.
#  9 A1    H1    II     348.
# 10 A1    H1    II     430.
# # ... with 770 more rows
  • Selecione variáveis com largura maior que * n *.
select_cols(data_vars, width_greater_than(3))
# # A tibble: 780 x 6
#    APLA_PLANT AIES_PLANT  CESP  DIES  MGRA  NGRA
#         <dbl>      <dbl> <dbl> <dbl> <dbl> <dbl>
#  1       2.45       2.39  16.9  52.1 228.    609
#  2       2.5        1.43  14.4  50.7 187.    427
#  3       2.69       1.52  16.5  54.7 230.    497
#  4       2.8        1.64  16.8  52.0 213.    523
#  5       2.62       1.55  15.9  51.6 224.    551
#  6       2.12       1.8   15    51.4 203.    529
#  7       3.15       1.78  10.9  41.9  75.2   294
#  8       2.97       1.84  15    53.4 204.    528
#  9       3.1        1.78  13.6  50.8 187.    538
# 10       3.02       1.6   16.3  53.9 250.    582
# # ... with 770 more rows
  • Selecione variáveis por tipo de letra

Vamos criar um conjunto de dados com nomes de colunas bagunçados.

df <- head(maize, 3)
colnames(df) <- c ("Amg", "hib", "Rep", "APLA", "AIES", "CESp", "dies", "Mgra", "mmG", "ngra")
select_cols(df, lower_case_only())
# # A tibble: 3 x 3
#   hib    dies  ngra
#   <chr> <dbl> <dbl>
# 1 H1     52.1   609
# 2 H1     50.7   427
# 3 H1     54.7   497
select_cols(df, upper_case_only())
# # A tibble: 3 x 2
#    APLA  AIES
#   <dbl> <dbl>
# 1  2.45  2.39
# 2  2.5   1.43
# 3  2.69  1.52
select_cols(df, title_case_only())
# # A tibble: 3 x 3
#   Amg   Rep    Mgra
#   <chr> <chr> <dbl>
# 1 A1    I      228.
# 2 A1    I      187.
# 3 A1    I      230.

7.1.2 Remover linhas ou colunas

Podemos usar remove_cols() e remove_rows() para remover colunas e linhas, respectivamente.

remove_cols(maize, AMB, HIB)
# # A tibble: 780 x 8
#    REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 I      2.45  2.39  16.9  52.1 228.   375.   609
#  2 I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 I      2.8   1.64  16.8  52.0 213.   408.   523
#  5 I      2.62  1.55  15.9  51.6 224.   406.   551
#  6 II     2.12  1.8   15    51.4 203.   383.   529
#  7 II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 II     2.97  1.84  15    53.4 204.   387.   528
#  9 II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

As funções remove_rows_na() e remove_rows_na() são usados para remover linhas e colunas com valores NA, respectivamente. 

data_with_na <- maize
data_with_na[c (1, 5, 10), c (3:5, 9:10)] <- NA
remove_cols_na(data_with_na)
# Warning: Column(s) REP, APLA, AIES, MMG, NGRA with NA values deleted.
# # A tibble: 780 x 5
#    AMB   HIB    CESP  DIES  MGRA
#    <chr> <chr> <dbl> <dbl> <dbl>
#  1 A1    H1     16.9  52.1 228. 
#  2 A1    H1     14.4  50.7 187. 
#  3 A1    H1     16.5  54.7 230. 
#  4 A1    H1     16.8  52.0 213. 
#  5 A1    H1     15.9  51.6 224. 
#  6 A1    H1     15    51.4 203. 
#  7 A1    H1     10.9  41.9  75.2
#  8 A1    H1     15    53.4 204. 
#  9 A1    H1     13.6  50.8 187. 
# 10 A1    H1     16.3  53.9 250. 
# # ... with 770 more rows
remove_rows_na(data_with_na)
# Warning: Row(s) 1, 5, 10 with NA values deleted.
# # A tibble: 777 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I      2.5   1.43  14.4  50.7 187.   437.   427
#  2 A1    H1    I      2.69  1.52  16.5  54.7 230.   464.   497
#  3 A1    H1    I      2.8   1.64  16.8  52.0 213.   408.   523
#  4 A1    H1    II     2.12  1.8   15    51.4 203.   383.   529
#  5 A1    H1    II     3.15  1.78  10.9  41.9  75.2  256.   294
#  6 A1    H1    II     2.97  1.84  15    53.4 204.   387.   528
#  7 A1    H1    II     3.1   1.78  13.6  50.8 187.   348.   538
#  8 A1    H1    III    2.69  1.52  15.6  49.5 195.   369.   529
#  9 A1    H1    III    2.6   1.68  14.3  48.9 172.   344.   500
# 10 A1    H1    III    2.82  1.52  18.4  54.3 255.   371.   689
# # ... with 767 more rows

7.1.3 Ordenar linhas

A função arrange() é utilizada para ordenar as linhas de um tibble (ou data.frames) com base em uma expressão envolvendo suas variáveis. Considerando as funções que vimos até aqui, vamos computar a média para a MGRA, criar uma nova variável chamada Rank, qual corresponde ao ranqueamento dos híbridos para a variável em questão e ordenar a variável Rank em ordem crescente, onde o híbrido com a maior média ficará na primeira linha.

maize %>%
  group_by(HIB) %>%
  summarise(MGRA_mean = mean(MGRA)) %>%
  mutate(Rank = rank(MGRA_mean)) %>%
  arrange(-Rank)
# # A tibble: 13 x 3
#    HIB   MGRA_mean  Rank
#    <chr>     <dbl> <dbl>
#  1 H6         188.    13
#  2 H2         187.    12
#  3 H4         184.    11
#  4 H1         184.    10
#  5 H5         184.     9
#  6 H13        180.     8
#  7 H7         171.     7
#  8 H3         169.     6
#  9 H11        167.     5
# 10 H10        164.     4
# 11 H8         160.     3
# 12 H12        157.     2
# 13 H9         153.     1

Exercício 3

  • Considerando o exemplo anterior, ordene a variável Rank em ordem decrescente.

Resposta

Ao combinar a função group_by() com arrange() é possível realizar o ordenamento para cada nível de um determinado fator. No exemplo abaixo, a variável APLA é ordenada de maneira crescente para cada híbrido.


maize %>%
  group_by(HIB) %>%
  arrange(APLA, .by_group = TRUE)
# # A tibble: 780 x 10
# # Groups:   HIB [13]
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A3    H1    II     1.93  0.93  13    50.0 120.   276.   433
#  2 A3    H1    I      2     1.05  19.9  53.3 253.   444.   570
#  3 A3    H1    I      2.07  1.05  13.2  47.9 110.   293.   377
#  4 A3    H1    II     2.08  0.94  12    47.6 103.   334.   309
#  5 A3    H1    III    2.1   0.97  17.5  50.8 222.   423.   524
#  6 A1    H1    II     2.12  1.8   15    51.4 203.   383.   529
#  7 A3    H1    I      2.12  1.03  18.5  52.0 214.   382.   560
#  8 A3    H1    III    2.12  0.96  15    56.8 174.   339.   512
#  9 A3    H1    I      2.13  1.05  11.6  47.0  89.5  300.   298
# 10 A4    H1    I      2.13  1.1   12.8  47.6 144.   280.   516
# # ... with 770 more rows

7.1.4 Selecionar top n linhas baseado em valor

A função top_n() é usada para selecionar linhas superiores ou inferiores em cada grupo.

# seleciona as duas linhas com o maior valor de MGRA
top_n(maize, 2, MGRA)
# # A tibble: 2 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H6    I      2.92  1.64  18    56.0  289.  393.   734
# 2 A1    H13   II     2.47  1.28  15.3  53.0  291.  417.   698

# seleciona as duas linhas com o menor valor de MGRA
top_n(maize, 2, -MGRA)
# # A tibble: 2 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H9    III    2.72  1.54  11    42.8  58.5  295.   198
# 2 A2    H8    I      1.92  0.63  12.1  39.7  59.5  243.   245

# Maior produtividade em cada ambiente
maize %>%
  group_by(AMB) %>%
  top_n(1, MGRA)
# # A tibble: 4 x 10
# # Groups:   AMB [4]
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H13   II     2.47  1.28  15.3  53.0  291.  417.   698
# 2 A2    H6    III    3.18  1.62  19.2  53.0  270.  382.   708
# 3 A3    H1    I      2     1.05  19.9  53.3  253.  444.   570
# 4 A4    H10   I      2.65  1.47  14    50.3  287.  275.   493

7.1.5 Adicionar novas variáveis

A função mutate() é utilizada quando se deseja adicionar novas variáveis no conjunto de dados. Estas variáveis são funções de variáveis existentes. Como exemplo, vamos criar uma nova variável chamada PRE_2 no conjunto de dados maize, qual será a razão entre AIES e APLA. Note que a função adiciona a nova variável após a última variável origina e mantém todas as demais. Digamos que queríamos adicionar a nova variável criada após a variável REP, a seguinte abordagem com o pacote dplyr deve ser usada.


maize %>% 
  mutate(PRE_2 = AIES/APLA) %>%
  select(AMB, HIB, REP, PRE_2, everything())
# # A tibble: 780 x 11
#    AMB   HIB   REP   PRE_2  APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I     0.976  2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H1    I     0.572  2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1    I     0.565  2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1    I     0.586  2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H1    I     0.592  2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H1    II    0.849  2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1    II    0.565  3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1    II    0.620  2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1    II    0.574  3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1    II    0.530  3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

Com a função add_cols(), o mesmo resultado pode ser obtido com:


add_cols(maize,
         PRE_2 = AIES/APLA,
         .after = REP)
# # A tibble: 780 x 11
#    AMB   HIB   REP   PRE_2  APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I     0.976  2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H1    I     0.572  2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1    I     0.565  2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1    I     0.586  2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H1    I     0.592  2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H1    II    0.849  2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1    II    0.565  3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1    II    0.620  2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1    II    0.574  3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1    II    0.530  3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

Exercício 2

  • Crie uma variável chamada MGRA_kg qual será o resultado em quilogramas da massa de grãos.

  • Selecione somente as colunas HIB, AMB, REP e MGRA_Kg.

  • Selecione somente as cinco linhas com maior valor de MGRA_Kg.

Resposta

7.1.6 Concatenar colunas

A função concatenate() pode ser usada para concatenar várias colunas de um conjunto de dados. concatenate() retorna um quadro de dados com todas as colunas originais em .data mais a variável concatenada, após a última coluna, nomeada como new_var. Para escolher a posição da nova variável, use o argumento .after ou.before, como a seguir.

concatenate(maize, AMB:REP, .after = REP)
# # A tibble: 780 x 11
#    AMB   HIB   REP   new_var   APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <chr>    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I     A1_H1_I   2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H1    I     A1_H1_I   2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1    I     A1_H1_I   2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1    I     A1_H1_I   2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H1    I     A1_H1_I   2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H1    II    A1_H1_II  2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1    II    A1_H1_II  3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1    II    A1_H1_II  2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1    II    A1_H1_II  3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1    II    A1_H1_II  3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

concatenate() também pode ser utilizada dentro de add_cols() para mutar um conjunto de dados. Para isso, é preciso utilizar o argumento pull = TRUE para que o valor concatenado seja exibido como um vetor. Note que agora o argumento .after é utilizado dentro da função add_cols().

maize %>% 
  add_cols(AMB_REP =  concatenate(., AMB:REP, pull = TRUE),
           .after = REP) %>% 
  head()
# # A tibble: 6 x 11
#   AMB   HIB   REP   AMB_REP   APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <chr>    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1    I     A1_H1_I   2.45  2.39  16.9  52.1  228.  375.   609
# 2 A1    H1    I     A1_H1_I   2.5   1.43  14.4  50.7  187.  437.   427
# 3 A1    H1    I     A1_H1_I   2.69  1.52  16.5  54.7  230.  464.   497
# 4 A1    H1    I     A1_H1_I   2.8   1.64  16.8  52.0  213.  408.   523
# 5 A1    H1    I     A1_H1_I   2.62  1.55  15.9  51.6  224.  406.   551
# 6 A1    H1    II    A1_H1_II  2.12  1.8   15    51.4  203.  383.   529

7.1.7 Formatar nomes de coluna

As funções colnames_to_lower(), colnames_to_upper() e colnames_to_title() podem ser usados para converter nomes de colunas em maiúsculas, minúsculas ou em formato de título, respectivamente . 

colnames_to_lower(maize) %>% head()
# # A tibble: 6 x 10
#   amb   hib   rep    apla  aies  cesp  dies  mgra   mmg  ngra
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1    I      2.45  2.39  16.9  52.1  228.  375.   609
# 2 A1    H1    I      2.5   1.43  14.4  50.7  187.  437.   427
# 3 A1    H1    I      2.69  1.52  16.5  54.7  230.  464.   497
# 4 A1    H1    I      2.8   1.64  16.8  52.0  213.  408.   523
# 5 A1    H1    I      2.62  1.55  15.9  51.6  224.  406.   551
# 6 A1    H1    II     2.12  1.8   15    51.4  203.  383.   529
colnames_to_upper(maize) %>% head()
# # A tibble: 6 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1    I      2.45  2.39  16.9  52.1  228.  375.   609
# 2 A1    H1    I      2.5   1.43  14.4  50.7  187.  437.   427
# 3 A1    H1    I      2.69  1.52  16.5  54.7  230.  464.   497
# 4 A1    H1    I      2.8   1.64  16.8  52.0  213.  408.   523
# 5 A1    H1    I      2.62  1.55  15.9  51.6  224.  406.   551
# 6 A1    H1    II     2.12  1.8   15    51.4  203.  383.   529
colnames_to_title(maize) %>% head()
# # A tibble: 6 x 10
#   Amb   Hib   Rep    Apla  Aies  Cesp  Dies  Mgra   Mmg  Ngra
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1    I      2.45  2.39  16.9  52.1  228.  375.   609
# 2 A1    H1    I      2.5   1.43  14.4  50.7  187.  437.   427
# 3 A1    H1    I      2.69  1.52  16.5  54.7  230.  464.   497
# 4 A1    H1    I      2.8   1.64  16.8  52.0  213.  408.   523
# 5 A1    H1    I      2.62  1.55  15.9  51.6  224.  406.   551
# 6 A1    H1    II     2.12  1.8   15    51.4  203.  383.   529

7.1.8 Reordenando colunas

A função reorder_cols() pode ser usada para reordenar as colunas de um quadro de dados.

reorder_cols(data_vars, contains("PLANT"), .before = AMB) %>% head()
# # A tibble: 6 x 10
#   APLA_PLANT AIES_PLANT AMB   HIB   REP    CESP  DIES  MGRA   MMG  NGRA
#        <dbl>      <dbl> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1       2.45       2.39 A1    H1    I      16.9  52.1  228.  375.   609
# 2       2.5        1.43 A1    H1    I      14.4  50.7  187.  437.   427
# 3       2.69       1.52 A1    H1    I      16.5  54.7  230.  464.   497
# 4       2.8        1.64 A1    H1    I      16.8  52.0  213.  408.   523
# 5       2.62       1.55 A1    H1    I      15.9  51.6  224.  406.   551
# 6       2.12       1.8  A1    H1    II     15    51.4  203.  383.   529
reorder_cols(data_vars, AMB, HIB, .after = REP) %>% head()
# # A tibble: 6 x 10
#   REP   AMB   HIB   APLA_PLANT AIES_PLANT  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr>      <dbl>      <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 I     A1    H1          2.45       2.39  16.9  52.1  228.  375.   609
# 2 I     A1    H1          2.5        1.43  14.4  50.7  187.  437.   427
# 3 I     A1    H1          2.69       1.52  16.5  54.7  230.  464.   497
# 4 I     A1    H1          2.8        1.64  16.8  52.0  213.  408.   523
# 5 I     A1    H1          2.62       1.55  15.9  51.6  224.  406.   551
# 6 II    A1    H1          2.12       1.8   15    51.4  203.  383.   529

É possível colocar as colunas no primeiro e no último lugar rapidamente com columns_to_first() e columns_to_last(), respectivamente.

column_to_first(maize, CESP, DIES) %>% head()
# # A tibble: 6 x 10
#    CESP  DIES AMB   HIB   REP    APLA  AIES  MGRA   MMG  NGRA
#   <dbl> <dbl> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1  16.9  52.1 A1    H1    I      2.45  2.39  228.  375.   609
# 2  14.4  50.7 A1    H1    I      2.5   1.43  187.  437.   427
# 3  16.5  54.7 A1    H1    I      2.69  1.52  230.  464.   497
# 4  16.8  52.0 A1    H1    I      2.8   1.64  213.  408.   523
# 5  15.9  51.6 A1    H1    I      2.62  1.55  224.  406.   551
# 6  15    51.4 A1    H1    II     2.12  1.8   203.  383.   529

7.1.9 Obtendo níveis de fatores

Para obter os níveis e o tamanho dos níveis de um fator, as funções get_levels() e get_level_size() pode ser usado. 

get_levels(maize, AMB)
# [1] "A1" "A2" "A3" "A4"
get_level_size(maize, AMB)
# # A tibble: 4 x 10
#   AMB     HIB   REP  APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
# * <chr> <int> <int> <int> <int> <int> <int> <int> <int> <int>
# 1 A1      195   195   195   195   195   195   195   195   195
# 2 A2      195   195   195   195   195   195   195   195   195
# 3 A3      195   195   195   195   195   195   195   195   195
# 4 A4      195   195   195   195   195   195   195   195   195

7.1.10 Selecionar linhas com base em seus valores

Utilizando a função filter() é possivel filtrar as linhas de um conjunto de dados com base no valor de suas variáveis. No primeiro exemplo, selecionaremos as linhas onde o valor da variável MGRA é maior que 280.

maize %>% 
  filter(MGRA > 280)
# # A tibble: 4 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H6    I      2.92  1.64  18    56.0  289.  393.   734
# 2 A1    H10   I      2.92  1.61  20.3  55.4  283.  441.   641
# 3 A1    H13   II     2.47  1.28  15.3  53.0  291.  417.   698
# 4 A4    H10   I      2.65  1.47  14    50.3  287.  275.   493

No segundo exemplo, selecionaremos apenas as linhas onde a MGRA é maior que 220 OU a APLA é menor que 1.3 OU o NGRA é maior que 820.

maize %>% 
  filter(MGRA > 280 | APLA < 1.3 | NGRA > 820)
# # A tibble: 10 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H6    I      2.92  1.64  18    56.0 289.   393.   734
#  2 A1    H10   I      2.92  1.61  20.3  55.4 283.   441.   641
#  3 A1    H13   II     2.47  1.28  15.3  53.0 291.   417.   698
#  4 A2    H8    II     1.03  0.69  10.8  44.8  94.8  277.   342
#  5 A2    H10   III    1.09  0.92  15    47.6 166.   299.   555
#  6 A3    H10   I      1.04  0.71  14.8  45.5 112.   265.   423
#  7 A3    H11   I      1     0.65  14.5  43.6 120.   210.   571
#  8 A4    H8    I      2.65  1.67  18    50   277.   251.   903
#  9 A4    H8    I      2.95  1.7   18.6  52.9 249.   302.   824
# 10 A4    H10   I      2.65  1.47  14    50.3 287.   275.   493

No último exemplo, selecionaremos apenas as linhas onde MGRA é maior que é maior que 220 E a APLA é menor que 2.

maize %>% 
  filter(MGRA > 220 & APLA < 2)
# # A tibble: 1 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H6    II     1.97  1.63  17.1  54.7  230.  375.   614

Isto é aproximadamente equivalente ao seguinte código R base.

maize[maize$MGRA > 220 & maize$APLA < 2, ]

7.2 Trabalhando com números e seqüências de caracteres

7.2.1 Arredondando

A função round_cols() arredonda uma coluna selecionada ou um quadro de dados inteiro para o número especificado de casas decimais (padrão 0). Se nenhuma variável for informada, todas as variáveis numéricas serão arredondadas.

round_cols(maize)
# # A tibble: 780 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I      2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H1    I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1    I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1    I      2.8   1.64  16.8  52.0 214.   408.   523
#  5 A1    H1    I      2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H1    II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1    II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1    II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1    II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1    II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

Como alternativa, selecione variáveis para arredondar.

round_cols(maize, MGRA, MMG, digits = 1)
# # A tibble: 780 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    I      2.45  2.39  16.9  52.1 228.   375    609
#  2 A1    H1    I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1    I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1    I      2.8   1.64  16.8  52.0 214.   408.   523
#  5 A1    H1    I      2.62  1.55  15.9  51.6 224.   406    551
#  6 A1    H1    II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1    II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1    II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1    II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1    II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

7.2.2 Extraindo e substituindo números

As funções extract_number() e replace_number() pode ser usado para extrair ou substituir números. Como exemplo, extrairemos o número de cada genótipo em maize criando uma nova coluna, HIB_NUM, inserindo após a coluna HIB.

maize %>% 
  add_cols(HIB_NUM = extract_number(HIB),
           .after = HIB)
# # A tibble: 780 x 11
#    AMB   HIB   HIB_NUM REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr>   <dbl> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1          1 I      2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H1          1 I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1          1 I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1          1 I      2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H1          1 I      2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H1          1 II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1          1 II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1          1 II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1          1 II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1          1 II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

Para substituir números de uma determinada coluna por uma substituição especificada, use replace_number(). Por padrão, os números são substituídos por "". O argumento drop epull também podem ser usados, como mostrado acima.

replace_number(maize, HIB)
# # A tibble: 780 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H     I      2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H     I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H     I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H     I      2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H     I      2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H     II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H     II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H     II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H     II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H     II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows
replace_number(maize,
               REP,
               pattern = "^I$",
               replacement = "REP_1")
# # A tibble: 780 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H1    REP_1  2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H1    REP_1  2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H1    REP_1  2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H1    REP_1  2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H1    REP_1  2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H1    II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H1    II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H1    II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H1    II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H1    II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

7.2.3 Extraindo, substituindo e removendo strings

As funções extract_string() e replace_string() são usados no mesmo contexto de extract_number() e replace_number(), mas para lidar com seqüências de caracteres.

extract_string(maize, HIB)
# # A tibble: 780 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    H     I      2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    H     I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    H     I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    H     I      2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    H     I      2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    H     II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    H     II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    H     II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    H     II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    H     II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

Para substituir strings, podemos usar a função replace_strings().

replace_string(maize,
               HIB,
               replacement = "HIB_")
# # A tibble: 780 x 10
#    AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1 A1    HIB_1 I      2.45  2.39  16.9  52.1 228.   375.   609
#  2 A1    HIB_1 I      2.5   1.43  14.4  50.7 187.   437.   427
#  3 A1    HIB_1 I      2.69  1.52  16.5  54.7 230.   464.   497
#  4 A1    HIB_1 I      2.8   1.64  16.8  52.0 213.   408.   523
#  5 A1    HIB_1 I      2.62  1.55  15.9  51.6 224.   406.   551
#  6 A1    HIB_1 II     2.12  1.8   15    51.4 203.   383.   529
#  7 A1    HIB_1 II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8 A1    HIB_1 II     2.97  1.84  15    53.4 204.   387.   528
#  9 A1    HIB_1 II     3.1   1.78  13.6  50.8 187.   348.   538
# 10 A1    HIB_1 II     3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

Para remover todas as seqüências de caracteres de um quadro de dados, use remove_strings().

remove_strings(maize)
# # A tibble: 780 x 10
#      AMB   HIB   REP  APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1     1     1    NA  2.45  2.39  16.9  52.1 228.   375.   609
#  2     1     1    NA  2.5   1.43  14.4  50.7 187.   437.   427
#  3     1     1    NA  2.69  1.52  16.5  54.7 230.   464.   497
#  4     1     1    NA  2.8   1.64  16.8  52.0 213.   408.   523
#  5     1     1    NA  2.62  1.55  15.9  51.6 224.   406.   551
#  6     1     1    NA  2.12  1.8   15    51.4 203.   383.   529
#  7     1     1    NA  3.15  1.78  10.9  41.9  75.2  256.   294
#  8     1     1    NA  2.97  1.84  15    53.4 204.   387.   528
#  9     1     1    NA  3.1   1.78  13.6  50.8 187.   348.   538
# 10     1     1    NA  3.02  1.6   16.3  53.9 250.   430.   582
# # ... with 770 more rows

7.2.4 Formatando strings

A função tidy_strings() organiza cadeias de caracteres, colunas não numéricas ou quaisquer colunas selecionadas em um quadro de dados, colocando todas as palavras em maiúsculas, substituindo qualquer espaço, tabulação e caracteres de pontuação por _ e colocando _ entre letras maiúsculas e minúsculas. Considere as seguintes cadeias de caracteres: messy_env por definição deve representar um nível único do ambiente de fator (ambiente 1). messy_gen mostra seis genótipos, emessy_int representa a interação desses genótipos com o ambiente 1.

messy_env <- c("ENV 1", "Env 1", "Env1", "env1", "Env.1", "Env_1")
messy_gen <- c("GEN1", "gen 2", "Gen.3", "gen-4", "Gen_5", "GEN_6")
messy_int <- c("Env1Gen1", "Env1_Gen2", "env1 gen3", "Env1 Gen4", "ENV_1GEN5", "ENV1GEN6")

Esses vetores de caracteres são visualmente confusos. Vamos arrumá-los.

tidy_strings(messy_env)
# [1] "ENV_1" "ENV_1" "ENV_1" "ENV_1" "ENV_1" "ENV_1"
tidy_strings(messy_gen)
# [1] "GEN_1" "GEN_2" "GEN_3" "GEN_4" "GEN_5" "GEN_6"
tidy_strings(messy_int)
# [1] "ENV_1_GEN_1" "ENV_1_GEN_2" "ENV_1_GEN_3" "ENV_1_GEN_4" "ENV_1_GEN_5"
# [6] "ENV_1_GEN_6"

O tidy_strings() também funciona para arrumar um quadro de dados inteiro ou colunas específicas. Vamos criar um quadro de dados ‘bagunçado’ no contexto de testes de melhoramento de plantas.

library(tibble)
df <- tibble(Env = messy_env,
             gen = messy_gen,
             Env_GEN = interaction(Env, gen),
             y = rnorm (6, 300, 10))
df
# # A tibble: 6 x 4
#   Env   gen   Env_GEN         y
#   <chr> <chr> <fct>       <dbl>
# 1 ENV 1 GEN1  ENV 1.GEN1   294.
# 2 Env 1 gen 2 Env 1.gen 2  300.
# 3 Env1  Gen.3 Env1.Gen.3   291.
# 4 env1  gen-4 env1.gen-4   302.
# 5 Env.1 Gen_5 Env.1.Gen_5  293.
# 6 Env_1 GEN_6 Env_1.GEN_6  318.
tidy_strings(df)
# # A tibble: 6 x 4
#   Env   gen   Env_GEN         y
#   <chr> <chr> <chr>       <dbl>
# 1 ENV_1 GEN_1 ENV_1_GEN_1  294.
# 2 ENV_1 GEN_2 ENV_1_GEN_2  300.
# 3 ENV_1 GEN_3 ENV_1_GEN_3  291.
# 4 ENV_1 GEN_4 ENV_1_GEN_4  302.
# 5 ENV_1 GEN_5 ENV_1_GEN_5  293.
# 6 ENV_1 GEN_6 ENV_1_GEN_6  318.
tidy_strings(df, gen)
# # A tibble: 6 x 4
#   Env   gen   Env_GEN         y
#   <chr> <chr> <fct>       <dbl>
# 1 ENV 1 GEN_1 ENV 1.GEN1   294.
# 2 Env 1 GEN_2 Env 1.gen 2  300.
# 3 Env1  GEN_3 Env1.Gen.3   291.
# 4 env1  GEN_4 env1.gen-4   302.
# 5 Env.1 GEN_5 Env.1.Gen_5  293.
# 6 Env_1 GEN_6 Env_1.GEN_6  318.

7.3 Selecionar linhas por sua posição

A função slice() é usada para selecionar linhas por sua posição ordinal no tibble. Os tibbles agrupados usam a posição ordinal dentro do grupo.

# seleciona as três primeiras linhas
slice(maize, 1:3)
# # A tibble: 3 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1    I      2.45  2.39  16.9  52.1  228.  375.   609
# 2 A1    H1    I      2.5   1.43  14.4  50.7  187.  437.   427
# 3 A1    H1    I      2.69  1.52  16.5  54.7  230.  464.   497
# Seleciona as 3 últimas linhas
slice(maize, 778:n())
# # A tibble: 3 x 10
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A4    H13   III    2.2   0.9   12.1  40.9  92.8  322.   288
# 2 A4    H13   III    2.15  1.07  10.6  46.0  91.4  300.   305
# 3 A4    H13   III    2.19  1.12  14.5  51.9 144.   352.   408
# seleciona as duas primeiras linhas de cada ambiente
maize %>%
  group_by(AMB) %>%
  slice(1:2)
# # A tibble: 8 x 10
# # Groups:   AMB [4]
#   AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1    I      2.45  2.39  16.9  52.1  228.  375.   609
# 2 A1    H1    I      2.5   1.43  14.4  50.7  187.  437.   427
# 3 A2    H1    I      3.06  1.89  18.2  54.4  244.  421.   581
# 4 A2    H1    I      3.04  1.89  15.4  53.4  193.  369.   523
# 5 A3    H1    I      2.12  1.03  18.5  52.0  214.  382.   560
# 6 A3    H1    I      2     1.05  19.9  53.3  253.  444.   570
# 7 A4    H1    I      2.13  1.1   12.8  47.6  144.  280.   516
# 8 A4    H1    I      2.3   1.25  13.1  50.0  140.  230.   609

7.4 Combinando os verbos para manipulação

Esta sessão tem o objetivo de demonstrar como os verbos dplyr em conjunto com as funções pivot_longer() do pacote tidyr21 e column_to_rownames() do pacote tibble22 podem ser combinados para construir uma matriz dupla entrada onde as linhas correspondem aos genótipos e as colunas correspondem aos ambientes. Esta matriz será preenchida com o valor médio da MGRA considerando apenas as duas primeiras repetições de cada híbrido em cada ambiente. 

maize %>%
  filter(REP %in% c("I", "II")) %>%
  group_by(AMB, HIB) %>%
  summarise(MGRA_me = mean(MGRA)) %>%
  pivot_wider(names_from = HIB, values_from = MGRA_me) %>%
  round_cols(digits = 1)
# # A tibble: 4 x 14
# # Groups:   AMB [4]
#   AMB      H1   H10   H11   H12   H13    H2    H3    H4    H5    H6    H7    H8
#   <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1 A1     200.  185.  199.  174.  222.  205.  201.  204.  190.  238.  185.  198.
# 2 A2     194.  151.  169.  136.  158.  219.  201.  193.  180.  204.  148.  116 
# 3 A3     147.  117   127.  153.  186.  161.  146.  150   147.  127.  146.  149.
# 4 A4     195.  180.  170.  191.  167   156.  148.  182.  209.  164.  195.  182.
# # ... with 1 more variable: H9 <dbl>

Note que a mesma tabela dupla entrada pode ser obtida com a função make_mat() do pacote metan.

maize %>%
  filter(REP %in% c("I", "II")) %>%
  make_mat(AMB, HIB, MGRA) %>% 
  round_cols(digits = 1)
#       H1   H10   H11   H12   H13    H2    H3    H4    H5    H6    H7    H8
# A1 200.2 185.1 199.3 174.5 221.9 204.9 201.3 204.4 189.5 238.2 184.8 198.2
# A2 193.8 151.3 168.7 136.2 158.3 218.8 200.6 193.3 180.1 204.5 148.2 116.0
# A3 147.2 117.0 127.1 153.1 186.5 160.6 146.4 150.0 147.1 127.4 146.4 148.7
# A4 195.2 179.5 169.5 190.9 167.0 155.5 147.7 182.1 208.7 164.3 195.4 181.9
#       H9
# A1 203.4
# A2 107.2
# A3 117.3
# A4 154.8

7.5 Trabalhando com duas tabelas ao mesmo tempo

7.5.1 Junções com mutação de dados

É raro que uma análise de dados envolva apenas uma única tabela de dados. Na prática, diversas tabela podem existir e ferramentas flexíveis para combiná-las são necessárias. No dplyr, existem três famílias de verbos que permitem trabalhar com duas tabelas ao mesmo tempo, permitindo: (i) juntar tabelas, (ii) Filtrar registros e (iii) realizar operações.

Os seguintes códigos criam três novos conjuntos de dados. maize2 contém dados de duas repetições para os híbridos H1:H5 nos ambientes H1 e H2. mean_h e mean_a contém as médias para os híbridos e ambientes, respectivamente. 

maize_small <- 
  maize %>%
  filter(HIB %in% c("H1", "H2", "H3")) %>%
  filter(AMB %in% c("A1", "A2"))

maize2 <- 
  maize_small %>% 
  means_by(AMB, HIB) %>% 
  select(AMB:APLA) %>% 
  round_cols(digits = 1)
maize2
# # A tibble: 6 x 3
#   AMB   HIB    APLA
#   <chr> <chr> <dbl>
# 1 A1    H1      2.7
# 2 A1    H2      2.8
# 3 A1    H3      2.9
# 4 A2    H1      2.9
# 5 A2    H2      2.9
# 6 A2    H3      2.9

mean_h <- 
  maize_small %>%
  means_by(HIB) %>% 
  select(HIB, contains("A")) %>% 
  round_cols(digits = 1)
mean_h
# # A tibble: 3 x 5
#   HIB    APLA  AIES  MGRA  NGRA
#   <chr> <dbl> <dbl> <dbl> <dbl>
# 1 H1      2.8   1.7  195.  506.
# 2 H2      2.9   1.5  211.  577.
# 3 H3      2.9   1.7  195.  542.

mean_a <-
  maize_small %>%
  means_by(AMB) %>% 
  select(AMB, contains("ES")) %>% 
  round_cols(digits = 1)
mean_a
# # A tibble: 2 x 4
#   AMB    AIES  CESP  DIES
#   <chr> <dbl> <dbl> <dbl>
# 1 A1      1.5  15.3  51.6
# 2 A2      1.8  15.4  51.8
  • Juntando a coluna MGRA e NGRA da tabela mean_h na tabela maize2 considerando as variáveis com mesmo nome nas duas tabelas (neste caso, HIB)
left_join(maize2, mean_h %>% select(HIB, MGRA, NGRA), by = "HIB")
# # A tibble: 6 x 5
#   AMB   HIB    APLA  MGRA  NGRA
#   <chr> <chr> <dbl> <dbl> <dbl>
# 1 A1    H1      2.7  195.  506.
# 2 A1    H2      2.8  211.  577.
# 3 A1    H3      2.9  195.  542.
# 4 A2    H1      2.9  195.  506.
# 5 A2    H2      2.9  211.  577.
# 6 A2    H3      2.9  195.  542.
  • Juntando as colunas da tabela mean_a na tabela maize2 
full_join(maize2, mean_a, by = "AMB")
# # A tibble: 6 x 6
#   AMB   HIB    APLA  AIES  CESP  DIES
#   <chr> <chr> <dbl> <dbl> <dbl> <dbl>
# 1 A1    H1      2.7   1.5  15.3  51.6
# 2 A1    H2      2.8   1.5  15.3  51.6
# 3 A1    H3      2.9   1.5  15.3  51.6
# 4 A2    H1      2.9   1.8  15.4  51.8
# 5 A2    H2      2.9   1.8  15.4  51.8
# 6 A2    H3      2.9   1.8  15.4  51.8

7.5.2 Junções com filtragem de dados

  • Filtrando as linhas da tabela maize2 com base nas variáveis que combinam na tabela mean_h (neste caso, a coluna HIB) 
semi_join(maize2, mean_h, by = c("HIB", "APLA"))
# # A tibble: 3 x 3
#   AMB   HIB    APLA
#   <chr> <chr> <dbl>
# 1 A1    H3      2.9
# 2 A2    H2      2.9
# 3 A2    H3      2.9
  • Filtrando as linhas da tabela maize2 com base nas variáveis que NÃO combinam na tabela mean_h (neste caso, a coluna HIB) 
anti_join(maize2, mean_h, by = c("HIB", "APLA"))
# # A tibble: 3 x 3
#   AMB   HIB    APLA
#   <chr> <chr> <dbl>
# 1 A1    H1      2.7
# 2 A1    H2      2.8
# 3 A2    H1      2.9

7.5.3 Operações com conjuntos (vetores)

Operações com conjuntos são importantes na análise de dados agronômicos. Por exemplo, se um genótipo foi selecionado por um determinado índice nos ambientes A, B e C, então, este determinado genótipo é a interseção dos ambientes A, B e C. A base R fornece funções para operações de conjunto, mas funciona com dois conjuntos de uma vez apenas. Vamos ver como podemos estimar a interseção de três conjuntos com funções R de base.

(A <- letters[1:4])
# [1] "a" "b" "c" "d"

(B <- letters[2:5])
# [1] "b" "c" "d" "e"

(C <- letters[3:7])
# [1] "c" "d" "e" "f" "g"

(D <- letters[1:12])
#  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l"

set_lits <- list(A = A, B = B, C = C, D = D)

# intersecção de A, B e C
intersect(intersect(A, B), C)
# [1] "c" "d"

Observe que precisamos chamar intersect() várias vezes neste caso. O novo grupo de funções set_union(), set_difference() e set_intersect() do pacote metan supera o problema de computação de união, interseção e diferenças de dois conjuntos apenas com as funções de base R.

# Intersecção de A e B
set_intersect(A, B)
# [1] "b" "c" "d"

# Intersecção de A, B e C
set_intersect(A, B, C)
# [1] "c" "d"


# União de todos os conjuntos
# Todas as funções entendem um objeto de classe lista

set_union(set_lits)
#  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l"

# Intersecção de todos os conjuntos
set_intersect(set_lits)
# [1] "c" "d"

7.5.4 Operações com conjuntos (data frames)

Nesta seção será demonstrado como é possivel utilizar operações de cojuntos como interseção e união. É esperado que as entradas x e y tenham as mesmas variáveis. Para isto, vamos criar dois novos conjuntos de dados chamados data_1_to_5 e data_3_to_10, quais contém, respectivamente as cinco primeiras linhas e as linhas 3 a 10 de maize. Note que a função slice() é utilizada para selecionar as linhas com base em sua posição.

library(tidyverse)
data_1_to_5 <- 
  maize %>%
  slice(1:5) %>% 
  add_cols(id = 1:5, .before = 1)
data_3_to_10 <- 
  maize %>%
  slice(3:10) %>% 
  add_cols(id = 3:10, .before = 1)

7.5.4.1 Interseção de conjuntos

A função set_intersect() (interseção de conjunto) retorna somente as linhas presentes nos dois conjuntos, neste caso, as linhas 3, 4 and 5 do conjunto maize

set_intersect(data_1_to_5, data_3_to_10)
# # A tibble: 3 x 11
#      id AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <int> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1     3 A1    H1    I      2.69  1.52  16.5  54.7  230.  464.   497
# 2     4 A1    H1    I      2.8   1.64  16.8  52.0  213.  408.   523
# 3     5 A1    H1    I      2.62  1.55  15.9  51.6  224.  406.   551

7.5.4.2 União de conjuntos

A função set_union() (união de conjunto) junta os dois conjuntos sem que haja duplicação de registros.

set_union(data_1_to_5, data_3_to_10)
# # A tibble: 10 x 11
#       id AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#    <int> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#  1     1 A1    H1    I      2.45  2.39  16.9  52.1 228.   375.   609
#  2     2 A1    H1    I      2.5   1.43  14.4  50.7 187.   437.   427
#  3     3 A1    H1    I      2.69  1.52  16.5  54.7 230.   464.   497
#  4     4 A1    H1    I      2.8   1.64  16.8  52.0 213.   408.   523
#  5     5 A1    H1    I      2.62  1.55  15.9  51.6 224.   406.   551
#  6     6 A1    H1    II     2.12  1.8   15    51.4 203.   383.   529
#  7     7 A1    H1    II     3.15  1.78  10.9  41.9  75.2  256.   294
#  8     8 A1    H1    II     2.97  1.84  15    53.4 204.   387.   528
#  9     9 A1    H1    II     3.1   1.78  13.6  50.8 187.   348.   538
# 10    10 A1    H1    II     3.02  1.6   16.3  53.9 250.   430.   582

7.5.4.3 Diferença de conjuntos

A função set_difference() (diferença de conjunto, ou complementar) cria uma tabela somente com os registros em data_1_to_5 que não estão em data_3_to_10.

set_difference(data_1_to_5, data_3_to_10)
# # A tibble: 2 x 11
#      id AMB   HIB   REP    APLA  AIES  CESP  DIES  MGRA   MMG  NGRA
#   <int> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
# 1     1 A1    H1    I      2.45  2.39  16.9  52.1  228.  375.   609
# 2     2 A1    H1    I      2.5   1.43  14.4  50.7  187.  437.   427