9  Textos, categorias, datas e valores ausentes

Pré-requisitos: Capítulo 6 e Capítulo 8 · Pacotes: stringr, forcats, lubridate e tidyr (carregados com o tidyverse), here

Objetivos de aprendizagem

Ao final deste capítulo, espera-se que o estudante seja capaz de padronizar textos e extrair partes deles, como códigos da CID-10; recodificar, reordenar e agrupar categorias; converter textos em datas, extrair componentes de datas, calcular intervalos de tempo e obter a semana epidemiológica; decodificar campos compostos dos sistemas de informação, como a idade do SIM; e diagnosticar e tratar valores ausentes, distinguindo ausências explícitas e implícitas.

Nos capítulos anteriores, trabalhamos sobretudo com números. Mas as bases de saúde estão cheias de outros tipos de informação: nomes de municípios escritos de formas diferentes, códigos de doenças, categorias que precisam ser reagrupadas, datas em formatos variados e, claro, informações ausentes. Este capítulo apresenta quatro pacotes do tidyverse feitos para lidar com cada uma dessas situações. Todos têm nomes de funções padronizados, o que ajuda a lembrar deles: as funções do stringr começam com str_, as do forcats começam com fct_, e as do lubridate têm nomes que descrevem o formato da data, como dmy().

Usaremos duas bases. A primeira é a de nascidos vivos de Rondônia em 2019. A segunda traz o número diário de casos e óbitos por COVID-19 notificados nos estados da Região Norte entre 2020 e 2022, compilado a partir dos boletins das secretarias estaduais de saúde e do Ministério da Saúde (COTA, 2020).

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

covid <- read_csv(here("dados", "covid_norte_2020_2022.csv"))
covid
#> # A tibble: 7,132 × 4
#>    data       uf    casos_novos obitos_novos
#>    <date>     <chr>       <dbl>        <dbl>
#>  1 2020-03-17 AC              3            0
#>  2 2020-03-18 AC              0            0
#>  3 2020-03-19 AC              1            0
#>  4 2020-03-20 AC              3            0
#>  5 2020-03-21 AC              4            0
#>  6 2020-03-22 AC              0            0
#>  7 2020-03-23 AC              6            0
#>  8 2020-03-24 AC              4            0
#>  9 2020-03-25 AC              2            0
#> 10 2020-03-26 AC              1            0
#> # ℹ 7,122 more rows

9.1 Manipulação de textos com stringr

Padronizando textos

Um mesmo município pode aparecer escrito de várias formas em bases diferentes, ou mesmo em uma única base preenchida à mão: com e sem acento, em maiúsculas ou minúsculas, com espaços sobrando. Antes de comparar ou agrupar textos, é preciso padronizá-los. As funções str_to_upper(), str_to_lower() e str_to_title() mudam a caixa das letras, e str_squish() remove espaços no início e no fim e reduz espaços repetidos a um só.

nomes <- c("  porto velho", "PORTO VELHO ", "Porto  Velho", "Ji-Paraná", "JI-PARANA")
str_squish(str_to_upper(nomes))
#> [1] "PORTO VELHO" "PORTO VELHO" "PORTO VELHO" "JI-PARANÁ"   "JI-PARANA"

Os três primeiros nomes viraram o mesmo texto. Os dois últimos ainda diferem pelo acento. Para removê-lo, usamos a função stri_trans_general() do pacote stringi, que é instalado junto com o stringr e converte caracteres acentuados em seus equivalentes sem acento.

nomes_padronizados <- nomes |>
  str_to_upper() |>
  str_squish() |>
  stringi::stri_trans_general("Latin-ASCII")
nomes_padronizados
#> [1] "PORTO VELHO" "PORTO VELHO" "PORTO VELHO" "JI-PARANA"   "JI-PARANA"
unique(nomes_padronizados)
#> [1] "PORTO VELHO" "JI-PARANA"

Agora há apenas dois municípios, como deveria ser. Essa sequência de padronização é útil sempre que precisamos comparar textos vindos de fontes diferentes. Ainda assim, como vimos no Capítulo 8, o ideal é usar códigos, e não nomes, para combinar tabelas.

Detectando, substituindo e extraindo

A função str_detect() verifica se um texto contém um padrão e devolve TRUE ou FALSE. Ela combina muito bem com filter().

nascidos |>
  distinct(munresnome) |>
  filter(str_detect(munresnome, "Oeste"))
#> # A tibble: 12 × 1
#>    munresnome              
#>    <chr>                   
#>  1 Alta Floresta D'Oeste   
#>  2 Novo Horizonte do Oeste 
#>  3 São Felipe D'Oeste      
#>  4 Itapuã do Oeste         
#>  5 Machadinho D'Oeste      
#>  6 Colorado do Oeste       
#>  7 Ouro Preto do Oeste     
#>  8 Santa Luzia D'Oeste     
#>  9 Espigão D'Oeste         
#> 10 Nova Brasilândia D'Oeste
#> 11 Alvorada D'Oeste        
#> 12 Pimenteiras do Oeste

A função str_replace_all() substitui todas as ocorrências de um padrão por outro texto, e str_length() conta o número de caracteres. A função str_sub(), que já usamos no capítulo anterior, extrai parte de um texto a partir das posições inicial e final. Já str_pad() faz o contrário de remover zeros: completa um texto até um certo tamanho, o que é útil para recuperar zeros à esquerda perdidos em códigos.

str_replace_all("Alta Floresta D'Oeste", "D'Oeste", "do Oeste")
#> [1] "Alta Floresta do Oeste"
str_length("Porto Velho")
#> [1] 11
str_sub("1100205", start = 1, end = 6)
#> [1] "110020"
str_pad("5", width = 2, pad = "0")
#> [1] "05"

Um pouco de expressões regulares

Os padrões usados pelas funções do stringr são, na verdade, expressões regulares, uma pequena linguagem para descrever textos. Não é preciso dominá-la, mas alguns símbolos resolvem a maior parte das situações. O acento circunflexo (^) indica o início do texto, e o cifrão ($), o fim. Colchetes indicam um conjunto de caracteres possíveis, como [A-Z] (qualquer letra maiúscula). O símbolo \\d representa qualquer algarismo, e um número entre chaves indica quantas vezes o elemento anterior se repete.

codigos <- c("110020", "1100205", "11002", "ABC123")
str_detect(codigos, "^\\d{6}$")
#> [1]  TRUE FALSE FALSE FALSE

O padrão ^\\d{6}$ significa “do início ao fim, exatamente seis algarismos”. Apenas o primeiro código o atende. Esse tipo de verificação ajuda a encontrar códigos de município digitados de forma errada.

Uma aplicação: os capítulos da CID-10

As causas de óbito e de internação são registradas com códigos da Classificação Internacional de Doenças (CID-10). Cada código começa com uma letra seguida de dois algarismos, que formam a categoria (como J18, pneumonia por microrganismo não especificado), e pode ter um quarto caractere, que detalha a subcategoria (como J18.9). Nos arquivos do DATASUS, o ponto costuma ser omitido, e o código aparece como J189. O vetor abaixo traz alguns códigos reais da CID-10, apenas para ilustrar.

causas <- c("I219", "J189", "P073", "A90", "C509", "I10", "X599", "J45")

Para agrupar as causas, usamos a categoria de três caracteres ou a letra inicial, que indica, em geral, o capítulo da classificação.

tibble(causa = causas) |>
  mutate(
    categoria = str_sub(causa, 1, 3),
    letra = str_sub(causa, 1, 1),
    capitulo = case_when(
      letra %in% c("A", "B") ~ "I. Doenças infecciosas e parasitárias",
      letra == "C" ~ "II. Neoplasias",
      letra == "I" ~ "IX. Doenças do aparelho circulatório",
      letra == "J" ~ "X. Doenças do aparelho respiratório",
      letra == "P" ~ "XVI. Afecções do período perinatal",
      letra %in% c("V", "W", "X", "Y") ~ "XX. Causas externas",
      .default = "Outros capítulos"
    )
  )
#> # A tibble: 8 × 4
#>   causa categoria letra capitulo                             
#>   <chr> <chr>     <chr> <chr>                                
#> 1 I219  I21       I     IX. Doenças do aparelho circulatório 
#> 2 J189  J18       J     X. Doenças do aparelho respiratório  
#> 3 P073  P07       P     XVI. Afecções do período perinatal   
#> 4 A90   A90       A     I. Doenças infecciosas e parasitárias
#> 5 C509  C50       C     II. Neoplasias                       
#> 6 I10   I10       I     IX. Doenças do aparelho circulatório 
#> 7 X599  X59       X     XX. Causas externas                  
#> 8 J45   J45       J     X. Doenças do aparelho respiratório

A regra pela letra inicial funciona para a maior parte dos capítulos, mas tem exceções. A letra D, por exemplo, é compartilhada entre as neoplasias benignas (capítulo II) e as doenças do sangue (capítulo III), e a letra H, entre as doenças do olho e as do ouvido. Para agrupamentos oficiais, como as listas de mortalidade usadas pelo Ministério da Saúde, é preciso usar os intervalos completos de códigos.

9.2 Variáveis categóricas com forcats

No Capítulo 3, vimos que fatores guardam categorias e a ordem entre elas. O pacote forcats facilita as tarefas mais comuns com fatores. Vamos usá-lo com as variáveis da base nascidos.

A função fct_infreq() ordena as categorias da mais frequente para a menos frequente, o que é útil em tabelas e gráficos de barras.

nascidos |>
  mutate(racacor = fct_infreq(racacor)) |>
  count(racacor)
#> # A tibble: 6 × 2
#>   racacor      n
#>   <fct>    <int>
#> 1 Parda    19594
#> 2 Branca    5386
#> 3 Preta      867
#> 4 Indígena   418
#> 5 Amarela    116
#> 6 <NA>       647

A função fct_relevel() move uma ou mais categorias para o início, definindo qual será a categoria de referência. Isso será importante nos capítulos de inferência, em que as comparações são feitas sempre em relação à primeira categoria.

levels(nascidos$parto)
#> [1] "Vaginal" "Cesáreo"
levels(fct_relevel(nascidos$parto, "Cesáreo"))
#> [1] "Cesáreo" "Vaginal"

A função fct_recode() muda os rótulos de algumas categorias, no formato novo = "antigo", e fct_collapse() agrupa várias categorias em uma.

nascidos |>
  mutate(
    escolaridade = fct_collapse(
      escmae,
      "Até 7 anos" = c("Nenhuma", "1 a 3 anos", "4 a 7 anos"),
      "8 a 11 anos" = "8 a 11 anos",
      "12 anos ou mais" = "12 anos ou mais"
    )
  ) |>
  count(escolaridade)
#> # A tibble: 4 × 2
#>   escolaridade        n
#>   <fct>           <int>
#> 1 Até 7 anos       5316
#> 2 8 a 11 anos     15633
#> 3 12 anos ou mais  5767
#> 4 <NA>              312

Quando há muitas categorias, as menos frequentes podem ser reunidas em “Outros” com fct_lump_n(), que mantém apenas as n mais frequentes.

nascidos |>
  mutate(municipio = fct_lump_n(munresnome, n = 5, other_level = "Outros municípios")) |>
  count(municipio, sort = TRUE)
#> # A tibble: 6 × 2
#>   municipio             n
#>   <fct>             <int>
#> 1 Outros municípios 11716
#> 2 Porto Velho        8437
#> 3 Ji-Paraná          2182
#> 4 Ariquemes          1729
#> 5 Vilhena            1590
#> 6 Cacoal             1374

A função fct_reorder() ordena as categorias segundo os valores de outra variável, como a mediana do peso em cada município. Ela é muito usada em gráficos, como veremos no Capítulo 10. Por fim, fct_na_value_to_level() transforma os valores ausentes em uma categoria explícita, o que permite mostrá-los em tabelas.

nascidos |>
  mutate(escmae = fct_na_value_to_level(escmae, level = "Ignorado")) |>
  count(escmae)
#> # A tibble: 6 × 2
#>   escmae              n
#>   <fct>           <int>
#> 1 Nenhuma            40
#> 2 1 a 3 anos        516
#> 3 4 a 7 anos       4760
#> 4 8 a 11 anos     15633
#> 5 12 anos ou mais  5767
#> 6 Ignorado          312

9.3 Datas com lubridate

Convertendo textos em datas

Datas são guardadas no R em uma classe própria, Date, que permite fazer contas, como calcular intervalos, e extrair componentes, como o mês. No arquivo do SINASC, a data de nascimento vem como texto no formato ddmmaaaa, sem separadores. O pacote lubridate tem funções cujo nome indica a ordem dos componentes: dmy() para dia, mês e ano, ymd() para ano, mês e dia, e assim por diante. Essas funções reconhecem automaticamente vários separadores, ou a ausência deles.

dmy("19022019")
#> [1] "2019-02-19"
dmy("19/02/2019")
#> [1] "2019-02-19"
ymd("2019-02-19")
#> [1] "2019-02-19"

As três linhas produzem a mesma data, exibida no formato padrão internacional (ano, mês, dia). Foi a função dmy() que o script preparar-sinasc.R usou para converter a coluna dtnasc, que agora é do tipo data.

class(nascidos$dtnasc)
#> [1] "Date"
range(nascidos$dtnasc)
#> [1] "2019-01-01" "2019-12-31"

A base de COVID-19 já foi lida com a coluna data no formato correto, porque o readr reconhece automaticamente datas no padrão aaaa-mm-dd.

Extraindo componentes

As funções year(), month(), day() e wday() extraem o ano, o mês, o dia e o dia da semana de uma data. O dia da semana é devolvido como número, com o domingo sendo o dia 1.

nascidos |>
  mutate(dia_semana = wday(dtnasc)) |>
  count(dia_semana) |>
  mutate(dia = c("dom", "seg", "ter", "qua", "qui", "sex", "sáb"))
#> # A tibble: 7 × 3
#>   dia_semana     n dia  
#>        <dbl> <int> <chr>
#> 1          1  2922 dom  
#> 2          2  4493 seg  
#> 3          3  4024 ter  
#> 4          4  4413 qua  
#> 5          5  4138 qui  
#> 6          6  3855 sex  
#> 7          7  3183 sáb

Os nascimentos são menos frequentes aos sábados e, sobretudo, aos domingos. Como os partos espontâneos se distribuem de forma aproximadamente uniforme ao longo da semana, essa diferença costuma ser atribuída aos partos agendados, principalmente às cesarianas eletivas, que raramente são marcadas para o fim de semana.

Intervalos de tempo

Datas podem ser subtraídas, e o resultado é a diferença em dias. Para expressar a diferença em outras unidades, como semanas ou anos completos, usamos interval() e time_length().

primeiro_caso <- min(covid$data[covid$uf == "RO" & covid$casos_novos > 0])
primeiro_caso
#> [1] "2020-03-20"

ymd("2022-12-31") - primeiro_caso
#> Time difference of 1016 days
time_length(interval(primeiro_caso, ymd("2022-12-31")), unit = "year")
#> [1] 2.783562

O mesmo raciocínio serve para calcular a idade de uma pessoa a partir da data de nascimento e de uma data de referência, ou o tempo entre o início dos sintomas e a notificação de um caso, um indicador importante da oportunidade da vigilância.

Semanas epidemiológicas

A vigilância epidemiológica organiza os dados por semana epidemiológica, que vai de domingo a sábado. A primeira semana do ano é aquela que termina no primeiro sábado de janeiro com pelo menos quatro dias no ano novo, de modo que um ano pode ter 52 ou 53 semanas e algumas datas do fim de dezembro pertencem à semana 1 do ano seguinte. As funções epiweek() e epiyear(), do lubridate, calculam a semana e o ano epidemiológicos segundo essa regra, a mesma usada no calendário epidemiológico brasileiro.

datas <- ymd(c("2023-12-30", "2023-12-31", "2024-01-06", "2024-01-07"))
tibble(data = datas, semana = epiweek(datas), ano_epi = epiyear(datas))
#> # A tibble: 4 × 3
#>   data       semana ano_epi
#>   <date>      <dbl>   <dbl>
#> 1 2023-12-30     52    2023
#> 2 2023-12-31      1    2024
#> 3 2024-01-06      1    2024
#> 4 2024-01-07      2    2024

O dia 31 de dezembro de 2023, um domingo, já pertence à semana 1 de 2024. Por isso, é importante usar epiyear(), e não year(), ao agrupar por semana epidemiológica. Vamos agregar os casos diários de COVID-19 em Rondônia por semana.

covid_semanal_ro <- covid |>
  filter(uf == "RO") |>
  mutate(ano_epi = epiyear(data), semana_epi = epiweek(data)) |>
  group_by(ano_epi, semana_epi) |>
  summarise(
    inicio_semana = min(data),
    casos = sum(casos_novos),
    obitos = sum(obitos_novos),
    .groups = "drop"
  )
covid_semanal_ro
#> # A tibble: 146 × 5
#>    ano_epi semana_epi inicio_semana casos obitos
#>      <dbl>      <dbl> <date>        <dbl>  <dbl>
#>  1    2020         12 2020-03-20        3      0
#>  2    2020         13 2020-03-22        3      0
#>  3    2020         14 2020-03-29        5      1
#>  4    2020         15 2020-04-05       23      1
#>  5    2020         16 2020-04-12       94      2
#>  6    2020         17 2020-04-19      200      3
#>  7    2020         18 2020-04-26      326     16
#>  8    2020         19 2020-05-03      609     18
#>  9    2020         20 2020-05-10      656     28
#> 10    2020         21 2020-05-17     1190     46
#> # ℹ 136 more rows

A função floor_date() oferece um caminho alternativo, arredondando cada data para o início da semana. Com week_start = 7, a semana começa no domingo, como no calendário epidemiológico.

covid |>
  mutate(semana = floor_date(data, unit = "week", week_start = 7))

9.4 Valores ausentes

Ausências explícitas e implícitas

Um valor pode faltar de duas maneiras. A ausência explícita é o NA que vemos na tabela, como a escolaridade não informada de uma mãe. A ausência implícita é uma linha que deveria existir e não existe. Em uma tabela de nascimentos por município e mês, por exemplo, um município pequeno pode não ter nenhum nascimento em algum mês, e então essa combinação simplesmente não aparece na contagem.

nascimentos_mes <- nascidos |>
  count(munresnome, mes_nasc)

nascimentos_mes |>
  filter(munresnome == "Castanheiras")
#> # A tibble: 11 × 3
#>    munresnome   mes_nasc     n
#>    <chr>        <fct>    <int>
#>  1 Castanheiras jan          2
#>  2 Castanheiras fev          1
#>  3 Castanheiras mar          4
#>  4 Castanheiras mai          5
#>  5 Castanheiras jun          5
#>  6 Castanheiras jul          4
#>  7 Castanheiras ago          1
#>  8 Castanheiras set          4
#>  9 Castanheiras out          3
#> 10 Castanheiras nov          2
#> 11 Castanheiras dez          1

Castanheiras, com 32 nascimentos no ano, aparece em apenas 11 meses. Se calculássemos a média mensal de nascimentos desse município com esta tabela, ela estaria superestimada, porque os meses sem nascimento ficariam de fora. A função complete(), do tidyr, cria as combinações ausentes, e o argumento fill diz com que valor preenchê-las.

nascimentos_mes |>
  complete(munresnome, mes_nasc, fill = list(n = 0)) |>
  filter(munresnome == "Castanheiras")
#> # A tibble: 12 × 3
#>    munresnome   mes_nasc     n
#>    <chr>        <fct>    <int>
#>  1 Castanheiras jan          2
#>  2 Castanheiras fev          1
#>  3 Castanheiras mar          4
#>  4 Castanheiras abr          0
#>  5 Castanheiras mai          5
#>  6 Castanheiras jun          5
#>  7 Castanheiras jul          4
#>  8 Castanheiras ago          1
#>  9 Castanheiras set          4
#> 10 Castanheiras out          3
#> 11 Castanheiras nov          2
#> 12 Castanheiras dez          1

Agora todos os doze meses aparecem, com zero no mês sem nascimentos. Esse cuidado é essencial em séries temporais de vigilância, em que semanas sem casos precisam aparecer como zero, e não desaparecer da série.

Funções para lidar com ausentes

Além de is.na() e na_if(), já vistas, três funções do tidyr são muito úteis. A função drop_na() remove as linhas com ausentes nas colunas indicadas. A função replace_na() substitui os ausentes por um valor. E a função fill() preenche os ausentes com o valor anterior ou seguinte, o que é útil em tabelas em que um valor só é escrito na primeira linha de cada grupo.

nascidos |>
  drop_na(semagestac) |>
  nrow()
#> [1] 25790

Remover registros com informação ausente é a solução mais simples, mas não é neutra. Se os registros sem informação forem diferentes dos demais (por exemplo, se a idade gestacional faltar mais em municípios com pior assistência), a análise feita só com os registros completos pode ficar enviesada. Métodos para lidar com esse problema, como a imputação múltipla, estão fora do escopo deste livro, mas o capítulo 20 do Manual de R para Epidemiologistas (BATRA et al., 2021) oferece uma introdução.

Completude como indicador de qualidade

A proporção de campos preenchidos, chamada de completude, é uma das dimensões usadas para avaliar a qualidade dos dados dos sistemas de informação. Com o que já sabemos, é simples calcular a completude de todas as variáveis de uma vez.

nascidos |>
  summarise(across(everything(), \(x) mean(!is.na(x)) * 100)) |>
  pivot_longer(everything(), names_to = "variavel", values_to = "completude") |>
  arrange(completude)
#> # A tibble: 21 × 2
#>    variavel        completude
#>    <chr>                <dbl>
#>  1 semagestac            95.4
#>  2 prematuro             95.4
#>  3 gestacao              95.4
#>  4 racacor               97.6
#>  5 escmae                98.8
#>  6 apgar5                99.6
#>  7 gravidez              99.7
#>  8 consultas             99.8
#>  9 pre_natal_7mais       99.8
#> 10 consultas_cat         99.8
#> # ℹ 11 more rows

A função everything() seleciona todas as colunas. O resultado mostra que a idade gestacional em semanas e a raça/cor são as variáveis menos preenchidas, embora todas tenham completude acima de 95%.

9.5 Campos compostos nos sistemas de informação

Alguns campos dos sistemas de informação guardam mais de uma informação em um único código. O exemplo mais conhecido é a idade no SIM. Ela é registrada com três algarismos: o primeiro indica a unidade de medida (0 para minutos, 1 para horas, 2 para dias, 3 para meses, 4 para anos e 5 para idades de 100 anos ou mais) e os dois seguintes indicam a quantidade. Assim, 405 significa 5 anos, 310 significa 10 meses, 215 significa 15 dias e 502 significa 102 anos. O SINAN usa uma lógica parecida, com quatro algarismos.

Vamos decodificar alguns valores, fictícios, mas escritos no formato do SIM.

obitos <- tibble(idade_codigo = c("405", "310", "215", "102", "478", "502", "999"))

obitos |>
  mutate(
    unidade = str_sub(idade_codigo, 1, 1),
    quantidade = as.numeric(str_sub(idade_codigo, 2, 3)),
    idade_anos = case_when(
      unidade == "4" ~ quantidade,
      unidade == "5" ~ quantidade + 100,
      unidade %in% c("0", "1", "2", "3") ~ 0,
      .default = NA
    ),
    menor_1_ano = unidade %in% c("0", "1", "2", "3")
  )
#> # A tibble: 7 × 5
#>   idade_codigo unidade quantidade idade_anos menor_1_ano
#>   <chr>        <chr>        <dbl>      <dbl> <lgl>      
#> 1 405          4                5          5 FALSE      
#> 2 310          3               10          0 TRUE       
#> 3 215          2               15          0 TRUE       
#> 4 102          1                2          0 TRUE       
#> 5 478          4               78         78 FALSE      
#> 6 502          5                2        102 FALSE      
#> 7 999          9               99         NA FALSE

Os óbitos com unidade em minutos, horas, dias ou meses são todos de menores de um ano, o que permite identificar os óbitos infantis. O código 999, usado para idade ignorada, resultou em NA. Na prática, o pré-processamento feito pela função process_sim() do microdatasus já realiza essa decodificação, criando as colunas IDADEminutos, IDADEhoras, IDADEdias, IDADEmeses e IDADEanos (SALDANHA; BASTOS; BARCELLOS, 2019). Saber como o campo foi construído, porém, ajuda a conferir o resultado e a trabalhar com dados que não passaram por esse pré-processamento.

9.6 Estudo de caso: a COVID-19 nos estados da Região Norte

Vamos usar as ferramentas do capítulo para preparar a série de casos de COVID-19 dos estados da Região Norte, que será usada para construir curvas epidêmicas no próximo capítulo.

O primeiro passo é conferir os dados. Séries de vigilância costumam ter correções: quando um caso é reclassificado, o número de casos novos de um dia pode ficar negativo.

covid |>
  filter(casos_novos < 0 | obitos_novos < 0) |>
  count(uf)
#> # A tibble: 6 × 2
#>   uf        n
#>   <chr> <int>
#> 1 AC        1
#> 2 AM        2
#> 3 PA        2
#> 4 RO       19
#> 5 RR        2
#> 6 TO        2

Há poucos registros negativos, mas eles existem. Como representam correções do total acumulado, não devem ser simplesmente apagados; ao somar os casos por semana, eles compensam registros anteriores. Vamos agregar os dados por estado e semana epidemiológica, transformar a sigla do estado em um fator com o nome por extenso e garantir que todas as semanas apareçam para todos os estados.

covid_semanal <- covid |>
  mutate(
    ano_epi = epiyear(data),
    semana_epi = epiweek(data),
    estado = fct_recode(uf,
                        "Acre" = "AC", "Amapá" = "AP", "Amazonas" = "AM",
                        "Pará" = "PA", "Rondônia" = "RO", "Roraima" = "RR",
                        "Tocantins" = "TO")
  ) |>
  group_by(estado, ano_epi, semana_epi) |>
  summarise(
    inicio_semana = min(data),
    casos = sum(casos_novos),
    obitos = sum(obitos_novos),
    .groups = "drop"
  ) |>
  complete(estado, nesting(ano_epi, semana_epi),
           fill = list(casos = 0, obitos = 0))

covid_semanal |>
  count(estado)
#> # A tibble: 7 × 2
#>   estado        n
#>   <fct>     <int>
#> 1 Acre        147
#> 2 Amazonas    147
#> 3 Amapá       147
#> 4 Pará        147
#> 5 Rondônia    147
#> 6 Roraima     147
#> 7 Tocantins   147

A função nesting(), dentro de complete(), garante que apenas as combinações de ano e semana que existem nos dados sejam usadas, evitando criar, por exemplo, uma semana 53 em anos que só têm 52. Todos os estados ficaram com o mesmo número de semanas. Por fim, identificamos a semana de maior número de casos em cada estado.

covid_semanal |>
  group_by(estado) |>
  slice_max(casos, n = 1) |>
  select(estado, ano_epi, semana_epi, inicio_semana, casos)
#> # A tibble: 7 × 5
#> # Groups:   estado [7]
#>   estado    ano_epi semana_epi inicio_semana casos
#>   <fct>       <dbl>      <dbl> <date>        <dbl>
#> 1 Acre         2022          5 2022-01-30     8045
#> 2 Amazonas     2022          3 2022-01-16    42082
#> 3 Amapá        2022          4 2022-01-23    15042
#> 4 Pará         2022          7 2022-02-13    20201
#> 5 Rondônia     2022          5 2022-01-30    17521
#> 6 Roraima      2020         26 2020-06-21     6221
#> 7 Tocantins    2022          4 2022-01-23    13393

Em quase todos os estados, a semana com mais casos ocorreu no início de 2022, durante a circulação da variante Ômicron, quando a transmissão foi muito alta, mas a proporção de casos graves foi menor que nas ondas anteriores. O próximo capítulo mostra como transformar essas séries em gráficos.

9.7 Exercícios

Fixação

  1. Padronize o vetor c("São Francisco do Guaporé", "SAO FRANCISCO DO GUAPORE", " são francisco do guaporé ") de modo que os três textos fiquem iguais.

  2. Conte quantos municípios de Rondônia têm a palavra “Oeste” no nome e quantos têm nomes compostos por mais de uma palavra (dica: um nome composto tem pelo menos um espaço).

  3. Calcule, para cada mês de 2019, o número de nascimentos em Rondônia e identifique o mês com menos nascimentos.

  4. Determine a semana e o ano epidemiológicos das datas 1º de janeiro de 2022, 1º de janeiro de 2023 e 31 de dezembro de 2022.

Aplicação

  1. Usando fct_collapse(), agrupe a raça/cor da mãe em “Branca”, “Preta ou parda”, “Indígena” e “Amarela”, e calcule a proporção de baixo peso em cada grupo.

  2. Agregue a base de COVID-19 por estado e mês (use floor_date() com unit = "month") e identifique, para cada estado, o mês com maior número de óbitos.

Desafio

  1. Decodifique as idades no formato do SIM c("000", "105", "203", "311", "419", "460", "501", "999") e classifique os óbitos em neonatal precoce (0 a 6 dias), neonatal tardio (7 a 27 dias), pós-neonatal (28 dias a menos de 1 ano) e não infantil. Considere que idades em minutos e horas correspondem ao primeiro dia de vida.

  2. Calcule a completude das variáveis da base nascidos para cada município e identifique os cinco municípios com menor completude da idade gestacional. Discuta como isso pode afetar a comparação da proporção de prematuridade entre os municípios.

9.8 Síntese

O pacote stringr padroniza textos (str_to_upper(), str_squish()), detecta e substitui padrões (str_detect(), str_replace_all()) e extrai partes de textos (str_sub()), com apoio de expressões regulares simples. O pacote forcats reordena categorias (fct_infreq(), fct_relevel(), fct_reorder()), muda rótulos (fct_recode()), agrupa categorias (fct_collapse(), fct_lump_n()) e torna os ausentes visíveis (fct_na_value_to_level()). O pacote lubridate converte textos em datas (dmy(), ymd()), extrai componentes (month(), wday()), calcula intervalos e obtém a semana e o ano epidemiológicos (epiweek(), epiyear()). Os valores ausentes podem ser explícitos ou implícitos; os implícitos são recuperados com complete(). A completude das variáveis é um indicador simples de qualidade dos dados. Campos compostos, como a idade do SIM, são decodificados combinando str_sub() e case_when().

Tabela 9.1: Funções apresentadas no capítulo.
Função Pacote Finalidade
str_to_upper(), str_to_lower(), str_to_title(), str_squish() stringr Padronizar textos
stri_trans_general() stringi Remover acentos
str_detect(), str_replace_all() stringr Detectar e substituir padrões
str_sub(), str_length(), str_pad() stringr Extrair, medir e completar textos
fct_infreq(), fct_relevel(), fct_reorder() forcats Reordenar categorias
fct_recode(), fct_collapse(), fct_lump_n() forcats Renomear e agrupar categorias
fct_na_value_to_level() forcats Tornar os ausentes uma categoria
dmy(), ymd() lubridate Converter textos em datas
year(), month(), day(), wday() lubridate Extrair componentes de datas
interval(), time_length() lubridate Calcular intervalos de tempo
epiweek(), epiyear(), floor_date() lubridate Semanas epidemiológicas e arredondamento de datas
complete(), nesting() tidyr Recuperar combinações ausentes
drop_na(), replace_na(), fill() tidyr Tratar valores ausentes
everything() tidyselect Selecionar todas as colunas

9.9 Para saber mais

O R para Ciência de Dados (WICKHAM; ÇETINKAYA-RUNDEL; GROLEMUND, 2023) dedica um capítulo a cada um dos temas tratados aqui: textos (capítulo 14), expressões regulares (15), fatores (16), datas (17) e valores faltantes (18). O Manual de R para Epidemiologistas (BATRA et al., 2021) trata de datas no capítulo 9, com uma seção específica sobre semanas epidemiológicas, de textos no capítulo 10, de fatores no capítulo 11 e de valores ausentes no capítulo 20. Faria (FARIA, 2024) apresenta o stringr, o forcats e o lubridate nos capítulos 10, 11 e 12.

Obra Capítulo Seções de interesse
R para Ciência de Dados (WICKHAM; ÇETINKAYA-RUNDEL; GROLEMUND, 2023) 14. Strings; 15. Expressões regulares; 16. Fatores; 17. Datas e horários; 18. Valores faltantes Modificando a ordem de um fator; Criando datas/horários; Intervalos de tempo; Valores faltantes implícitos
Manual de R para Epidemiologistas (BATRA et al., 2021) 9. Trabalhando com datas; 10. Caracteres e strings; 11. Fatores; 20. Campos em branco/faltantes Semanas epidemiológicas; Limpe e padronize; Combine os níveis; Avalie os campos em branco
Introdução à Linguagem R (FARIA, 2024) 10. Manipulação e transformação de strings com stringr; 11. Introduzindo fatores com forcats; 12. Introdução à variáveis de tempo com lubridate —