6  Transformação de dados com dplyr

Pré-requisitos: Capítulo 3 e Capítulo 5 · Pacotes: dplyr (carregado com o tidyverse), here, janitor

Objetivos de aprendizagem

Ao final deste capítulo, espera-se que o estudante seja capaz de explicar a lógica comum às funções do dplyr, que recebem uma tabela e devolvem outra tabela; encadear operações com o operador pipe; selecionar, renomear e reordenar colunas; filtrar e ordenar linhas; remover registros duplicados; criar e modificar variáveis, inclusive com regras condicionais e faixas de valores; e transformar códigos de “ignorado” em valores ausentes.

Os dados raramente chegam prontos para a análise. Quase sempre é preciso escolher as variáveis de interesse, restringir os registros a uma população, criar novas variáveis a partir das existentes e corrigir códigos. O pacote dplyr foi criado para tornar essas tarefas simples e legíveis. Neste capítulo, vamos usá-lo para preparar a base de nascidos vivos importada no capítulo anterior.

library(tidyverse)
library(here)

sinasc <- read_csv2(
  here("dados", "sinasc_ro_2019.csv"),
  locale = locale(encoding = "latin1"),
  col_types = cols(CODMUNRES = col_character(), DTNASC = col_character())
) |>
  janitor::clean_names()

6.1 A gramática da transformação de dados

O dplyr faz parte do tidyverse, uma coleção de pacotes que compartilham a mesma forma de organizar os dados e de nomear as funções (WICKHAM et al., 2019). Suas principais funções são chamadas de verbos, porque cada uma faz uma ação bem definida sobre uma tabela. Todos os verbos seguem a mesma lógica. O primeiro argumento é sempre a tabela de dados. Os argumentos seguintes dizem o que fazer, usando os nomes das colunas sem aspas e sem cifrão. O resultado é sempre uma nova tabela, e a original não é alterada.

Os verbos se dividem conforme o que afetam. Alguns trabalham sobre as colunas: select() escolhe colunas, rename() muda nomes, relocate() muda a ordem e mutate() cria ou altera colunas. Outros trabalham sobre as linhas: filter() escolhe linhas que atendem a uma condição, arrange() ordena e distinct() remove repetições. No próximo capítulo veremos os verbos que trabalham sobre grupos de linhas.

6.2 O operador pipe

Em uma análise real, aplicamos vários verbos em sequência. Imagine que queremos as colunas de peso e de idade gestacional apenas dos nascimentos por parto vaginal, ordenados do menor para o maior peso. Sem nenhum recurso especial, teríamos de aninhar as funções umas dentro das outras.

arrange(select(filter(sinasc, parto == "Vaginal"), peso, semagestac), peso)

O código funciona, mas é difícil de ler, porque precisa ser lido de dentro para fora. O operador pipe, escrito |>, resolve o problema. Ele pega o resultado do que está à sua esquerda e o passa como primeiro argumento da função à sua direita. A mesma operação fica assim.

sinasc |>
  filter(parto == "Vaginal") |>
  select(peso, semagestac) |>
  arrange(peso)
#> # A tibble: 8,943 × 2
#>     peso semagestac
#>    <dbl>      <dbl>
#>  1   285         38
#>  2   295         38
#>  3   320         21
#>  4   335         41
#>  5   350         25
#>  6   370         39
#>  7   380         41
#>  8   404         35
#>  9   425         21
#> 10   430         22
#> # ℹ 8,933 more rows

Agora o código pode ser lido de cima para baixo, como uma receita. Uma boa forma de ler o |> em voz alta é “e então”. Pegue a base sinasc, e então filtre os partos vaginais, e então selecione o peso e a idade gestacional, e então ordene pelo peso.

O |> faz parte do próprio R desde a versão 4.1. Em muitos materiais, inclusive em algumas das obras de referência deste livro, aparece outro operador, %>%, do pacote magrittr, que faz praticamente a mesma coisa. Os dois podem ser usados indistintamente nos exemplos deste livro. No RStudio, o atalho Ctrl + Shift + M (Cmd + Shift + M no macOS) digita o pipe; se a opção recomendada no Capítulo 1 estiver marcada, será digitado o |>.

6.3 Operações sobre colunas

As bases do DATASUS costumam ter dezenas de colunas, e cada análise usa apenas algumas. A função select() escolhe as colunas desejadas, na ordem em que forem informadas.

sinasc |>
  select(munresnome, dtnasc, peso, parto)
#> # A tibble: 27,028 × 4
#>    munresnome              dtnasc    peso parto  
#>    <chr>                   <chr>    <dbl> <chr>  
#>  1 Alta Floresta D'Oeste   19022019  3685 Cesáreo
#>  2 Alta Floresta D'Oeste   21022019  3055 Cesáreo
#>  3 Alta Floresta D'Oeste   25022019  3460 Cesáreo
#>  4 Alto Alegre dos Parecis 20032019  2982 Cesáreo
#>  5 Alta Floresta D'Oeste   23032019  3310 Cesáreo
#>  6 Alta Floresta D'Oeste   27032019  2740 Cesáreo
#>  7 Novo Horizonte do Oeste 01042019  3158 Cesáreo
#>  8 Alta Floresta D'Oeste   01042019  3192 Cesáreo
#>  9 Alta Floresta D'Oeste   28022019  3570 Cesáreo
#> 10 Alta Floresta D'Oeste   11032019  3900 Cesáreo
#> # ℹ 27,018 more rows

Também é possível excluir colunas com o sinal de menos e selecionar intervalos de colunas vizinhas com dois-pontos.

sinasc |> select(-locnasc, -qtdfilvivo)
sinasc |> select(sexo:idademae)

Para bases com muitas variáveis, existem funções auxiliares que selecionam colunas pelo nome ou pelo tipo. As mais úteis são starts_with(), ends_with() e contains(), que procuram um trecho no nome da coluna, e where(), que seleciona colunas que satisfazem uma condição, como ser numérica.

sinasc |> select(starts_with("apgar"))
#> # A tibble: 27,028 × 2
#>    apgar1 apgar5
#>     <dbl>  <dbl>
#>  1      9     10
#>  2      8      9
#>  3      8     10
#>  4      9     10
#>  5      8     10
#>  6      9     10
#>  7      9     10
#>  8      9     10
#>  9      8      9
#> 10      9     10
#> # ℹ 27,018 more rows
sinasc |> select(where(is.numeric))
#> # A tibble: 27,028 × 9
#>     peso idademae estcivmae semagestac consultas apgar1 apgar5 qtdfilvivo
#>    <dbl>    <dbl>     <dbl>      <dbl>     <dbl>  <dbl>  <dbl>      <dbl>
#>  1  3685       19         5         39         4      9     10          0
#>  2  3055       29         2         38         4      8      9          1
#>  3  3460       37         9         40         4      8     10          2
#>  4  2982       30         5         38         3      9     10          0
#>  5  3310       30         2         38         4      8     10          1
#>  6  2740       33         5         38         4      9     10          2
#>  7  3158       37         1         38         4      9     10          1
#>  8  3192       27         2         39         4      9     10          0
#>  9  3570       20         5         39         3      8      9          0
#> 10  3900       30         2         39         4      9     10          1
#> # ℹ 27,018 more rows
#> # ℹ 1 more variable: locnasc <dbl>

A função rename() muda o nome de uma coluna, no formato novo_nome = nome_antigo, e relocate() muda sua posição.

sinasc |>
  rename(municipio = munresnome, idade_mae = idademae) |>
  relocate(peso, .before = municipio) |>
  head(3)
#> # A tibble: 3 × 18
#>   codmunres  peso municipio      dtnasc sexo  idade_mae escmae estcivmae racacor
#>   <chr>     <dbl> <chr>          <chr>  <chr>     <dbl> <chr>      <dbl> <chr>  
#> 1 110001     3685 Alta Floresta… 19022… Masc…        19 8 a 1…         5 Branca 
#> 2 110001     3055 Alta Floresta… 21022… Femi…        29 8 a 1…         2 Branca 
#> 3 110001     3460 Alta Floresta… 25022… Femi…        37 8 a 1…         9 Branca 
#> # ℹ 9 more variables: gestacao <chr>, semagestac <dbl>, gravidez <chr>,
#> #   parto <chr>, consultas <dbl>, apgar1 <dbl>, apgar5 <dbl>, qtdfilvivo <dbl>,
#> #   locnasc <dbl>

6.4 Operações sobre linhas

Filtrando linhas

A função filter() mantém apenas as linhas em que a condição informada é verdadeira. As condições são escritas com os operadores relacionais e lógicos do Capítulo 2.

sinasc |>
  filter(idademae < 20)
#> # A tibble: 4,558 × 18
#>    codmunres munresnome     dtnasc sexo   peso idademae escmae estcivmae racacor
#>    <chr>     <chr>          <chr>  <chr> <dbl>    <dbl> <chr>      <dbl> <chr>  
#>  1 110001    Alta Floresta… 19022… Masc…  3685       19 8 a 1…         5 Branca 
#>  2 110001    Alta Floresta… 28032… Femi…  2995       18 1 a 3…         5 Parda  
#>  3 110001    Alta Floresta… 17042… Masc…  3180       19 12 an…         1 Branca 
#>  4 110001    Alta Floresta… 10042… Masc…  2685       18 4 a 7…         2 Branca 
#>  5 110001    Alta Floresta… 10042… Masc…  3785       19 8 a 1…         5 Indíge…
#>  6 110001    Alta Floresta… 23042… Femi…  3980       18 4 a 7…         1 <NA>   
#>  7 110001    Alta Floresta… 24042… Femi…  2830       18 8 a 1…         5 Indíge…
#>  8 110001    Alta Floresta… 28052… Masc…  4245       14 4 a 7…         1 Parda  
#>  9 110001    Alta Floresta… 02052… Masc…  2925       17 4 a 7…         5 Indíge…
#> 10 110001    Alta Floresta… 16052… Masc…  3310       19 8 a 1…         1 Parda  
#> # ℹ 4,548 more rows
#> # ℹ 9 more variables: gestacao <chr>, semagestac <dbl>, gravidez <chr>,
#> #   parto <chr>, consultas <dbl>, apgar1 <dbl>, apgar5 <dbl>, qtdfilvivo <dbl>,
#> #   locnasc <dbl>

Dos 27.028 nascimentos, 4.558 foram de mães com menos de 20 anos. Várias condições podem ser combinadas. Separar as condições por vírgula equivale a ligá-las com &, ou seja, todas precisam ser verdadeiras.

sinasc |>
  filter(idademae < 20, parto == "Cesáreo") |>
  nrow()
#> [1] 2359

Para condições do tipo “ou”, usamos |. Para verificar se um valor pertence a uma lista, usamos %in%. E a função between() simplifica condições de intervalo.

sinasc |> filter(munresnome %in% c("Porto Velho", "Ji-Paraná", "Ariquemes"))
sinasc |> filter(between(semagestac, 32, 36))
Filtros e valores ausentes

A função filter() só mantém as linhas em que a condição é TRUE. Linhas em que a condição resulta em NA, porque a variável está ausente, são descartadas sem aviso. Por exemplo, filter(semagestac < 37) deixa de fora tanto os nascimentos a termo quanto os 1.238 nascimentos sem informação de idade gestacional. Quando os ausentes importam, é preciso tratá-los explicitamente com is.na(), como em filter(semagestac < 37 | is.na(semagestac)).

Ordenando linhas

A função arrange() ordena as linhas pelos valores de uma ou mais colunas, em ordem crescente. Para ordem decrescente, usamos desc().

sinasc |>
  select(munresnome, peso, semagestac) |>
  arrange(desc(peso)) |>
  head(5)
#> # A tibble: 5 × 3
#>   munresnome       peso semagestac
#>   <chr>           <dbl>      <dbl>
#> 1 Espigão D'Oeste  5985         38
#> 2 Rolim de Moura   5720         37
#> 3 Ji-Paraná        5480         39
#> 4 Cacoal           5470         37
#> 5 Jaru             5190         39

Removendo duplicatas e selecionando linhas por posição

A função distinct() mantém apenas as combinações únicas das colunas informadas. É útil, por exemplo, para obter a lista de municípios presentes na base.

sinasc |>
  distinct(codmunres, munresnome) |>
  arrange(munresnome)
#> # A tibble: 53 × 2
#>    codmunres munresnome             
#>    <chr>     <chr>                  
#>  1 110001    Alta Floresta D'Oeste  
#>  2 110037    Alto Alegre dos Parecis
#>  3 110040    Alto Paraíso           
#>  4 110034    Alvorada D'Oeste       
#>  5 110002    Ariquemes              
#>  6 110045    Buritis                
#>  7 110003    Cabixi                 
#>  8 110060    Cacaulândia            
#>  9 110004    Cacoal                 
#> 10 110070    Campo Novo de Rondônia 
#> # ℹ 43 more rows

As funções da família slice_*() selecionam linhas pela posição ou pelos valores extremos. A função slice_head() pega as primeiras linhas, e slice_max() e slice_min() pegam as linhas com os maiores ou menores valores de uma variável.

sinasc |>
  slice_min(peso, n = 3) |>
  select(munresnome, peso, semagestac)
#> # A tibble: 3 × 3
#>   munresnome           peso semagestac
#>   <chr>               <dbl>      <dbl>
#> 1 Colorado do Oeste     258         38
#> 2 Ouro Preto do Oeste   285         38
#> 3 Ji-Paraná             292         39

6.5 Criação e modificação de variáveis

A função mutate()

A função mutate() cria novas colunas ou modifica as existentes, sempre a partir de cálculos com as outras colunas. Vamos criar o peso em quilogramas.

sinasc |>
  mutate(peso_kg = peso / 1000) |>
  select(peso, peso_kg) |>
  head(3)
#> # A tibble: 3 × 2
#>    peso peso_kg
#>   <dbl>   <dbl>
#> 1  3685    3.68
#> 2  3055    3.06
#> 3  3460    3.46

Uma coluna criada com uma comparação vira uma variável lógica, com TRUE e FALSE. É a forma mais simples de criar indicadores, como o de baixo peso ao nascer.

sinasc |>
  mutate(baixo_peso = peso < 2500) |>
  count(baixo_peso)
#> # A tibble: 2 × 2
#>   baixo_peso     n
#>   <lgl>      <int>
#> 1 FALSE      25142
#> 2 TRUE        1886

Transformações condicionais

Quando a nova variável depende de uma condição com duas alternativas, usamos if_else(). O primeiro argumento é a condição, o segundo é o valor quando ela é verdadeira e o terceiro, o valor quando é falsa.

sinasc |>
  mutate(tipo_gravidez = if_else(gravidez == "Única", "Única", "Múltipla")) |>
  count(tipo_gravidez)
#> # A tibble: 3 × 2
#>   tipo_gravidez     n
#>   <chr>         <int>
#> 1 Múltipla        497
#> 2 Única         26452
#> 3 <NA>             79

Repare que os registros com gravidez ausente continuam ausentes, porque a condição não pode ser avaliada para eles.

Quando há mais de duas alternativas, a função case_when() é mais adequada. Ela recebe uma sequência de pares no formato condição ~ valor, avaliados em ordem. O primeiro par verdadeiro define o valor; o argumento .default indica o valor para os casos que não se encaixam em nenhuma condição.

A variável consultas, por exemplo, registra o número de consultas de pré-natal em códigos. No dicionário do SINASC, 1 significa nenhuma consulta, 2 significa de 1 a 3, 3 significa de 4 a 6, 4 significa 7 ou mais e 9 significa ignorado.

sinasc |>
  mutate(
    consultas_cat = case_when(
      consultas == 1 ~ "Nenhuma",
      consultas == 2 ~ "1 a 3",
      consultas == 3 ~ "4 a 6",
      consultas == 4 ~ "7 ou mais",
      .default = NA
    )
  ) |>
  count(consultas, consultas_cat)
#> # A tibble: 5 × 3
#>   consultas consultas_cat     n
#>       <dbl> <chr>         <int>
#> 1         1 Nenhuma         986
#> 2         2 1 a 3          1379
#> 3         3 4 a 6          5988
#> 4         4 7 ou mais     18624
#> 5         9 <NA>             51

Faixas de valores

Variáveis contínuas, como a idade, muitas vezes são agrupadas em faixas. A função cut(), do R base, faz isso a partir de pontos de corte (breaks) e rótulos (labels). Por padrão, cada intervalo inclui o limite superior e exclui o inferior.

sinasc |>
  mutate(
    faixa_idade_mae = cut(
      idademae,
      breaks = c(-Inf, 19, 34, Inf),
      labels = c("Menos de 20", "20 a 34", "35 ou mais")
    )
  ) |>
  count(faixa_idade_mae)
#> # A tibble: 3 × 2
#>   faixa_idade_mae     n
#>   <fct>           <int>
#> 1 Menos de 20      4558
#> 2 20 a 34         19327
#> 3 35 ou mais       3143

Os cortes acima formam os intervalos até 19 anos, de 20 a 34 anos e de 35 anos ou mais, faixas muito usadas em saúde materno-infantil por corresponderem às mães adolescentes e às gestações em idade materna avançada. Os valores -Inf e Inf garantem que nenhuma idade fique de fora.

Códigos de ignorado

Como vimos no Capítulo 3, os sistemas de informação registram a falta de informação com códigos, como o 9. Se esses códigos não forem convertidos em NA, entram nos cálculos como se fossem valores reais. A função na_if() substitui um valor específico por NA.

sinasc |>
  mutate(consultas = na_if(consultas, 9)) |>
  count(consultas)
#> # A tibble: 5 × 2
#>   consultas     n
#>       <dbl> <int>
#> 1         1   986
#> 2         2  1379
#> 3         3  5988
#> 4         4 18624
#> 5        NA    51

Os 51 registros com código 9 passaram a ser tratados como ausentes. A decisão de converter um código em NA deve sempre se basear no dicionário de dados, porque o mesmo número pode ter significados diferentes em variáveis diferentes.

6.6 Boas práticas na transformação de dados

Algumas recomendações tornam o trabalho com o dplyr mais seguro. A primeira é não sobrescrever a base original enquanto se testam transformações. Crie as novas variáveis, confira o resultado com count() ou summary() e só depois guarde a base transformada em um objeto. A segunda é preferir criar novas variáveis a modificar as existentes, mantendo a original para conferência, como fizemos com consultas e consultas_cat. A terceira é quebrar sequências longas em etapas com nomes claros, cada uma com um comentário explicando o objetivo. A quarta é registrar as definições operacionais, como os pontos de corte usados, que condicionam a comparação com outros estudos.

6.7 Estudo de caso: construindo variáveis de interesse no SINASC

Vamos agora reunir as transformações em uma única sequência, criando a base que será usada nos próximos capítulos. O objetivo é preparar variáveis para estudar o baixo peso ao nascer e sua relação com características maternas e da gestação.

nascidos <- sinasc |>
  # variáveis de interesse
  select(codmunres, munresnome, dtnasc, sexo, peso, idademae, escmae,
         racacor, gestacao, semagestac, gravidez, parto, consultas, apgar5) |>
  # códigos de ignorado
  mutate(consultas = na_if(consultas, 9)) |>
  # novas variáveis
  mutate(
    baixo_peso = peso < 2500,
    prematuro = semagestac < 37,
    mae_adolescente = idademae < 20,
    pre_natal_7mais = consultas == 4,
    faixa_idade_mae = cut(idademae,
                          breaks = c(-Inf, 19, 34, Inf),
                          labels = c("Menos de 20", "20 a 34", "35 ou mais")),
    consultas_cat = case_when(
      consultas == 1 ~ "Nenhuma",
      consultas == 2 ~ "1 a 3",
      consultas == 3 ~ "4 a 6",
      consultas == 4 ~ "7 ou mais"
    )
  )

glimpse(nascidos)
#> Rows: 27,028
#> Columns: 20
#> $ codmunres       <chr> "110001", "110001", "110001", "110037", "110001", "110…
#> $ munresnome      <chr> "Alta Floresta D'Oeste", "Alta Floresta D'Oeste", "Alt…
#> $ dtnasc          <chr> "19022019", "21022019", "25022019", "20032019", "23032…
#> $ sexo            <chr> "Masculino", "Feminino", "Feminino", "Feminino", "Femi…
#> $ peso            <dbl> 3685, 3055, 3460, 2982, 3310, 2740, 3158, 3192, 3570, …
#> $ idademae        <dbl> 19, 29, 37, 30, 30, 33, 37, 27, 20, 30, 31, 21, 21, 18…
#> $ escmae          <chr> "8 a 11 anos", "8 a 11 anos", "8 a 11 anos", "12 anos …
#> $ racacor         <chr> "Branca", "Branca", "Branca", "Parda", "Parda", "Branc…
#> $ gestacao        <chr> "37 a 41 semanas", "37 a 41 semanas", "37 a 41 semanas…
#> $ semagestac      <dbl> 39, 38, 40, 38, 38, 38, 38, 39, 39, 39, 40, 38, 41, 39…
#> $ gravidez        <chr> "Única", "Única", "Única", "Única", "Única", "Única", …
#> $ parto           <chr> "Cesáreo", "Cesáreo", "Cesáreo", "Cesáreo", "Cesáreo",…
#> $ consultas       <dbl> 4, 4, 4, 3, 4, 4, 4, 4, 3, 4, 4, 3, 4, 3, 4, 3, 4, 3, …
#> $ apgar5          <dbl> 10, 9, 10, 10, 10, 10, 10, 10, 9, 10, 9, 10, 9, 9, 7, …
#> $ baixo_peso      <lgl> FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE…
#> $ prematuro       <lgl> FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE…
#> $ mae_adolescente <lgl> TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,…
#> $ pre_natal_7mais <lgl> TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE…
#> $ faixa_idade_mae <fct> Menos de 20, 20 a 34, 35 ou mais, 20 a 34, 20 a 34, 20…
#> $ consultas_cat   <chr> "7 ou mais", "7 ou mais", "7 ou mais", "4 a 6", "7 ou …

Com a base pronta, podemos responder a uma primeira pergunta. Qual a proporção de baixo peso entre os filhos de mães adolescentes e entre os filhos das demais mães? Por enquanto, vamos responder com o que já conhecemos, filtrando cada grupo e tirando a média de uma variável lógica, que dá a proporção de TRUE.

nascidos |>
  filter(mae_adolescente) |>
  pull(baixo_peso) |>
  mean() * 100
#> [1] 8.446687

nascidos |>
  filter(!mae_adolescente) |>
  pull(baixo_peso) |>
  mean() * 100
#> [1] 6.680018

A função pull() extrai uma coluna como vetor, para que possamos aplicar mean(). A proporção de baixo peso foi de 8,4% entre os filhos de mães adolescentes e de 6,7% entre os filhos das demais mães. Fazer essa comparação para muitos grupos, um de cada vez, seria trabalhoso. No próximo capítulo, veremos como calcular indicadores para todos os grupos de uma só vez.

Saúde Pública em foco

As variáveis criadas neste estudo de caso correspondem a definições operacionais consagradas: baixo peso ao nascer como peso inferior a 2.500 gramas, prematuridade como idade gestacional inferior a 37 semanas completas e mãe adolescente como idade inferior a 20 anos. Ao relatar resultados, essas definições, assim como o tratamento dado aos registros com informação ignorada, devem ser descritas na seção de métodos. Pequenas diferenças de definição, como incluir ou não os registros ignorados no denominador, podem mudar os indicadores o suficiente para tornar duas análises incomparáveis.

Guardando a preparação em um script

Como essa preparação será usada em vários capítulos, ela foi reunida em um script, scripts/preparar-sinasc.R, que importa o arquivo, padroniza os nomes, trata os códigos de ignorado e cria as variáveis acima (e algumas outras que serão explicadas nos próximos capítulos). A partir do próximo capítulo, basta executá-lo com a função source() para ter a base nascidos pronta.

source(here("scripts", "preparar-sinasc.R"))

Essa é uma prática comum em projetos de análise. A preparação dos dados fica em um único lugar e, se for preciso corrigir algo, a correção vale para todas as análises que dependem dela.

6.8 Exercícios

Fixação

  1. Selecione, da base sinasc, apenas as colunas de município de residência, peso e Apgar no quinto minuto (apgar5), e ordene os registros do menor para o maior Apgar.

  2. Quantos nascimentos ocorreram em Porto Velho? E quantos em Porto Velho com peso inferior a 1.500 gramas (muito baixo peso)?

  3. Crie a variável peso_cat com as categorias “Menos de 2.500 g”, “2.500 a 3.999 g” e “4.000 g ou mais”, usando case_when(). Confira o resultado com count().

  4. Explique por que filter(sinasc, semagestac < 37) e filter(sinasc, !(semagestac >= 37)) retornam o mesmo número de linhas, e por que nenhuma das duas inclui os registros sem idade gestacional.

Aplicação

  1. Usando a base nascidos, calcule a proporção de prematuridade entre os nascimentos por parto cesáreo e por parto vaginal. Como os registros sem idade gestacional afetam o cálculo? Mostre o resultado com e sem na.rm = TRUE.

  2. Crie a variável escolaridade_baixa, verdadeira quando a escolaridade da mãe for “Nenhuma”, “1 a 3 anos” ou “4 a 7 anos”, usando %in%. Calcule a proporção de baixo peso entre as mães com e sem escolaridade baixa.

Desafio

  1. Classifique os nascidos vivos em muito baixo peso (menos de 1.500 g), baixo peso (1.500 a 2.499 g), peso adequado (2.500 a 3.999 g) e macrossomia (4.000 g ou mais). Pesquise na literatura a origem desses pontos de corte e discuta se faz sentido usá-los independentemente da idade gestacional.

  2. A variável gestacao traz a idade gestacional em faixas, e a variável semagestac traz a idade em semanas. Crie, a partir de semagestac, uma variável com as mesmas faixas de gestacao e compare as duas com count(). Os resultados coincidem? Que explicações são possíveis para eventuais diferenças?

6.9 Síntese

O dplyr organiza a transformação de dados em verbos, cada um com uma tarefa. Sobre as colunas, select() escolhe, rename() renomeia, relocate() reordena e mutate() cria ou modifica. Sobre as linhas, filter() escolhe as que atendem a uma condição, arrange() ordena, distinct() remove repetições e slice_*() seleciona por posição ou por valores extremos. O operador pipe (|>) encadeia os verbos em uma sequência que pode ser lida de cima para baixo. Novas variáveis podem ser criadas com comparações, com if_else() e case_when() para regras condicionais e com cut() para faixas de valores. Os códigos de ignorado devem ser convertidos em NA com na_if(), sempre com base no dicionário de dados.

Tabela 6.1: Funções apresentadas no capítulo.
Função Pacote Finalidade
\|>, %>% base, magrittr Encadear operações
select(), rename(), relocate() dplyr Escolher, renomear e reordenar colunas
starts_with(), ends_with(), contains(), where() tidyselect Auxiliares de seleção de colunas
filter(), between() dplyr Filtrar linhas
arrange(), desc() dplyr Ordenar linhas
distinct(), slice_head(), slice_max(), slice_min() dplyr Remover duplicatas e selecionar linhas
mutate() dplyr Criar e modificar variáveis
if_else(), case_when() dplyr Transformações condicionais
cut() base Agrupar valores contínuos em faixas
na_if() dplyr Converter um código em NA
count(), pull() dplyr Contar categorias e extrair uma coluna
source() base Executar um script

6.10 Para saber mais

O capítulo 3 do R para Ciência de Dados (WICKHAM; ÇETINKAYA-RUNDEL; GROLEMUND, 2023) apresenta os verbos do dplyr com uma base de voos, e os capítulos 12 e 13 tratam de variáveis lógicas e numéricas, incluindo if_else(), case_when() e cut(). O capítulo 8 do Manual de R para Epidemiologistas (BATRA et al., 2021) mostra um fluxo completo de limpeza de uma base de surto, com recodificação, criação de faixas etárias e filtragem, e é uma leitura muito recomendada para quem trabalha com vigilância. Faria (FARIA, 2024) apresenta o tidyverse no capítulo 3 e os verbos do dplyr no capítulo 5.

Obra Capítulo Seções de interesse
R para Ciência de Dados (WICKHAM; ÇETINKAYA-RUNDEL; GROLEMUND, 2023) 3. Transformação de dados; 12. Vetores lógicos; 13. Números Linhas; Colunas; O pipe; Transformações condicionais
Manual de R para Epidemiologistas (BATRA et al., 2021) 8. Limpeza de dados e principais funções Selecionar ou reordenar colunas; Criação de coluna e transformação; Re-codificar valores; Categorias numéricas; Filtrar linhas
Introdução à Linguagem R (FARIA, 2024) 3. Introduzindo o universo do tidyverse; 5. Transformando dados com dplyr Operador pipe; select(); filter(); arrange(); mutate()
Practical Statistics in Medicine with R (BOUGIOUKAS, 2025) 10. Data import, pre-processing, and transformation —