R é uma das linguagens de programação mais populares para ciência de dados, estatística, economia e várias outras áreas quantitativas. O R já vem com alguns pacotes “imbutidos” que, em geral, são referidos como base R, são os pacotes que são instalados automaticamente junto com o R como o stats, utils, graphics, datasets entre outros.

Ou seja, já é possível importar dados e limpá-los, fazer análises estatísticas, gráficos e tabelas sem carregar nenhum pacote adicional.

Mas para o usufruir de todo o potencial que o R pode oferecer é essencial conhecer os melhores pacotes e as suas funções.

A lista de pacotes essenciais

Nome do Pacote	Principal Uso
`data.table`	Manipulação de dados extremamente veloz para bigdata
`dplyr` + `tidyr`	Manipulação de dados
`readr`	Importar e exportar arquivos
`stringr`	Trabalhar com strings
`lubridate`	Trabalhar com datas
`ggplot2`	Visualização de dados com varias extensões
`knitr` + `shiny` + `rmarkdown` + `quarto`	Desenvolvimento de relatórios, apresentações, dashboards e Apps
`dbplyr`	Interface para interagir com Bases de Dados (SQL, PostGreSQL, etc.)

A verdade é que cada usuário de R tem demandas específicas, então é difícil dizer quais são os pacotes indisipensáveis. Por isso o foco da minha lista foi em pacotes que facilitam três partes essenciais de qualquer análise de dados: importação, manipulação e apresentação dos dados.

Independentemente do foco do seu projeto ou da sua pesquisa eu garanto que será necessário:

Importar dados no R
Transformar esses dados
Apresentar seus resultados na forma de gráficos, tabelas, relatórios, dashboards, etc.

Importar dados

Tabelas csv

Quando comecei a usar R uma das partes mais agoniantes era conseguir importar arquivos de dados externos corretamente. As funções read.csv, read.csv2, read.delim funcionam bem, mas o readr tornou isso tudo muito mais fácil.

O pacote essencialmente tem funções read_* (read_csv, read_fwf, etc.) que servem para importar dados e funções write_ (write_csv, write_excel_csv, etc.) que servem para exportar dados num formato específico.

Além das funções read_* e write_*, vale a pena explorar as funções parse_* como parse_number e parse_date que são muito convenientes para garantir que seus dados estejam sendo interpretados da maneira correta.

Para arquivos mais pesados vale considerar duas opções: vroom e data.table. O primeiro é um pacote enxuto que permite a importação e exportação rápida de arquivos csv mais pesados. Já a segunda opção é um pacote completo, que será disuctido em maiores detalhes abaixo, de importação e manipulação de dados. A função data.table::fread é extremamente veloz.

Outros formatos

Se você utiliza dados em formatos mais específicos então outros pacotes se tornam essenciais. A lista abaixo cita alguns dos casos mais comuns:

haven - SPSS, SAS e Stata
readxl - Excel
jsonlite - Json
sf - Shapefiles em geral

Por fim, vale notar um pacote simpático chamado rio que tem duas funções centrais import e export. Essas funções automaticamente detectam o tipo de arquivo que você quer importar ou exportar e chamam a função do pacote apropriado para executar a tarefa.

A única desvantagem desta conveniência é que em casos mais complicados pode ser difícil lembrar do nome dos argumentos da função que você precisa. Por exemplo, o import usa o o readxl para importar um arquivo xlsx. Mas você precisa lembrar de cabeça que o argumento para selecionar uma aba específica é sheet.

Manipulação de dados

Toda análise começa com uma base de dados (ou muitas bases de dados). E se você já se aventurou o suficiente no mundo, você sabe que são raríssimas as bases de dados que já vem prontas no momento em que você baixa o csv ou xlsx. Na grande maioria dos casos, é preciso passar por diversas etapas de limpeza ou de pré-processamento para transformar os dados em algo que possa ser analisado.

O R tem várias funções no seu core para realizar essas tarefas mas há dois pacotes essenciais que melhoram (e muito) essa tarefa: dplyr e data.table.

dplyr x data.table

O dplyr é bastante intuitivo, poderoso e há centenas de tutoriais e livros sobre ele. Ele serve para transformar os dados: criar colunas, filtrar linhas, reordernar dados, etc. Ele integra um “ecossistema” de pacotes chamado tidyverse, uma coleção de pacotes para processamento e visualização de dados, construídos em torno de uma filosofia comum.

O data.table surgiu com o intuito de fazer o R funcionar melhor num mundo de big data. Seu desenvolvimento foi focado em ser o mais rápido, eficiente e sucinto possível, permitindo trabalhar com bases de dados muito grandes dentro do R (~100GB). Em termos de velocidade, o data.table ganha facilmente de praticamente todas as outras linguagens populares em data science. Ele é centena de vezes mais rápido que base R e também ganha com folga do seu competidor dplyr.

Se o data.table é tão mais eficiente então como o dplyr se tornou mais popular do que ele?

Acontece que o dplyr é melhor integrado com vários outros pacotes podersos do tidyverse. Também há muito material de apoio ao dplyr na forma de tutoriais, vídeos, livros, etc. disponíveis na internet. Quase todo curso de R ensina a usar o dplyr. Assim, a curva de aprendizado fica mais fácil.

O data.table funciona muito bem com funções do base R como lapply, colMeans(), etc. e tem uma sintaxe concisa e flexível, onde o usuário acaba tendo bastante liberdade para criar as suas soluções. Já o dplyr vai pelo caminho de tentar facilitar ao máximo a vida do usuário criando várias funções com usos bastante específicos para otimizar pequenas tarefas do dia-a-dia do processamento de dados.

Outra pequena desvantagem do data.table é que ele não funciona de primeira no Mac. Como ele usa OpenMP é preciso baixar outros programas e modificar algumas configurações no R o que pode ser bem trabalhoso e chato.

Na comparação fica o seguinte:

`dplyr`	`data.table`
Mais funções para aprender. Em geral, o código fica mais comprido	Sintaxe sucinta
Funções melhor integradas com o `tidyverse`	Funções melhor integradas com base `R`
Muito mais veloz que o base `R`	Opção mais veloz possível
Sintaxe mais intuitiva, mais material de apoio na internet, mais popular.	Menos material de apoio disponível

tidyverse

Indepedentemente da sua escolha entre dplyr e/ou data.table (recomendo usar os dois!) vale a pena explorar os demais pacotes do tidyverse.

tidyr

O tidyr acrescenta algumas importantes funcionalidades que faltam no dplyr. Talvez as duas funções mais importantes do pacote sejam pivot_longer e pivot_wider que servem para converter seus dados de transversais (wide) para longitudinais (long) e vice-versa. O tidyr também traz um novo tipo de objeto o tibble, uma versão moderna do data.frame.

Vale também explorar algumas funções muito úteis como separate, fill, complete, replace_na entre outras.

library(tidyr)
library(dplyr)
# Exemplo de tibble
data <- as_tibble(USPersonalExpenditure)
data <- mutate(data, variable = rownames(USPersonalExpenditure))
data

# A tibble: 5 × 6
  `1940` `1945` `1950` `1955` `1960` variable           
   <dbl>  <dbl>  <dbl>  <dbl>  <dbl> <chr>              
1 22.2   44.5    59.6    73.2  86.8  Food and Tobacco   
2 10.5   15.5    29      36.5  46.2  Household Operation
3  3.53   5.76    9.71   14    21.1  Medical and Health 
4  1.04   1.98    2.45    3.4   5.4  Personal Care      
5  0.341  0.974   1.8     2.6   3.64 Private Education

# Exemplo de dado longitudinal
long <- pivot_longer(data, cols = !variable, names_to = "year")
long

# A tibble: 25 × 3
   variable            year  value
   <chr>               <chr> <dbl>
 1 Food and Tobacco    1940   22.2
 2 Food and Tobacco    1945   44.5
 3 Food and Tobacco    1950   59.6
 4 Food and Tobacco    1955   73.2
 5 Food and Tobacco    1960   86.8
 6 Household Operation 1940   10.5
 7 Household Operation 1945   15.5
 8 Household Operation 1950   29  
 9 Household Operation 1955   36.5
10 Household Operation 1960   46.2
# ℹ 15 more rows

# Calcula a variação e apresenta de maneira transversal
long %>%
  group_by(variable) %>%
  mutate(variacao = (value / lag(value) - 1) * 100) %>%
  na.omit() %>%
  pivot_wider(
    id_cols = "variable",
    names_from = "year",
    values_from = "variacao")

# A tibble: 5 × 5
# Groups:   variable [5]
  variable            `1945` `1950` `1955` `1960`
  <chr>                <dbl>  <dbl>  <dbl>  <dbl>
1 Food and Tobacco     100.    33.9   22.8   18.6
2 Household Operation   47.6   87.1   25.9   26.6
3 Medical and Health    63.2   68.6   44.2   50.7
4 Personal Care         90.4   23.7   38.8   58.8
5 Private Education    186.    84.8   44.4   40

stringr

O stringr é um pacote voltado para facilitar a manipulação de vetores de texto (character). Todas as funções do pacote são convenientemente precedidas pelo prefixo str_ e a lista dos argumentos segue um padrão uniforme. O nome das funções também é bastante intuitivo.

Novamente, há funções base como gsub, grep, strsplit, sub, entre outras, que servem para manipular vetores de string, mas essas funções carecem de “coesão interna” e em alguns casos elas podem retornar valores inesperados ou “erros silenciosos”.

Uma função muito divertida do pacote é a str_glue que facilita na hora de concatenar strings. Note como é simples incluir variáveis como parte do texto e inclusive fazer transformações nas variáveis.

library(stringr)

nome <- "Vinicius Oike"
idade <- 29
nfav <- runif(1, min = 0, max = 10)

str_glue("Olá, meu nome é {nome}, tenho {idade} anos. Ano que vem, terei {idade + 1} anos. Meu número favorito é {round(nfav)}.")

Olá, meu nome é Vinicius Oike, tenho 29 anos. Ano que vem, terei 30 anos. Meu número favorito é 8.

lubridate

O lubridate é um pacote exclusivamente focado em manipulação de vetores de datas e tudo relacionado ao tempo como variável. Variáveis de datas podem ser uma dor de cabeça tremenda no processo de limpeza de dados, pois há inúmeros formatos diferentes, que variam para cada país, fora os problemas potenciais de ano bissextos, fusos-horários diferentes, etc.

Especialmente para quem precisa trabalhar com séries de tempo ou dados em painel, o lubridate é um pacote é essencial.

O pacote também facilita “operações aritméticas” com datas como no exemplo abaixo:

library(lubridate)

start <- ymd("2020-01-15")
start + years(1) + months(3)

[1] "2021-04-15"

Ele também permite a extração de qualquer informação específica de uma data

agora <- ymd_hms("2022-06-10 20:36:15")

Como o dia da semana:

wday(agora)

[1] 6

O trimestre:

quarter(agora)

[1] 2

Ou o mês (com a opção de ter a abreviação do mês já no padrão desejado!):

month(agora, label = TRUE, locale = "pt_BR")

[1] Jun
12 Levels: Jan < Fev < Mar < Abr < Mai < Jun < Jul < Ago < Set < ... < Dez

dbplyr

O dbplyr é um pacote muito interessante que transforma o R numa “interface” para o SQL. O pacote traduz código escrito em dplyr para código em SQL. Assim, é possível acessar, transformar e baixar dados de uma Base de Dados em SQL, PostGreSQL, etc. diretamente no R.

O código abaixo é um exemplo (bem artficial) que demonstra o funcionamento da pacote. A função show_query() não costuma ser usada na prática, mas ela serve para mostrar o que o pacote está fazendo.

library(dplyr)
library(dbplyr)

# Abre um servidor SQL para servir de exemplo
con <- DBI::dbConnect(RSQLite::SQLite(), dbname = ":memory:")
# Faz o update da tabela mtcars para esse servidor
copy_to(con, mtcars)
# Acessa a tabela do servidor usando tbl
db <- tbl(con, "mtcars")

# Trabalha normalmente usando comandos do dplyr
db %>%
  filter(cyl %in% c(4, 6)) %>%
  mutate(disp = log(round(disp))) %>%
  group_by(cyl) %>%
  summarise(a1 = mean(disp, na.rm = TRUE), a2 = median(wt, na.rm = TRUE)) %>%
  arrange(desc(a1)) %>%
  # No lugar de show_query() use collect() para baixar os dados
  show_query()

<SQL>
SELECT `cyl`, AVG(`disp`) AS `a1`, MEDIAN(`wt`) AS `a2`
FROM (
  SELECT
    `mpg`,
    `cyl`,
    LOG(ROUND(`disp`, 0)) AS `disp`,
    `hp`,
    `drat`,
    `wt`,
    `qsec`,
    `vs`,
    `am`,
    `gear`,
    `carb`
  FROM `mtcars`
  WHERE (`cyl` IN (4.0, 6.0))
)
GROUP BY `cyl`
ORDER BY `a1` DESC

Visualização de dados

Aqui a lista fica simples pois o ggplot2 é simplesmente indispensável. O ggplot2 foi lançado em 2005 e até hoje ainda é o pacote mais baixado de R na lista oficial do CRAN. É um pacote sinônimo de R e dá um baile em qualquer outro pacote de visualização.

O ggplot2 tem uma sintaxe bastante intuitiva em que o usário vai adicionando camadas e elementos sobre o gráfico.

library(ggplot2)

ggplot(data = mtcars, aes(x = wt, y = mpg)) +
  geom_smooth(color = "#ef476f", method = "lm", se = FALSE) +
  geom_point(aes(color = as.factor(cyl))) +
  scale_color_manual(name = "", values = c("#073b4c", "#06d6a0", "#ffd166")) +
  theme_bw()

O pacote por si só já é muito poderoso, mas há ainda inúmeras extensões desnenvolvidas por outros usuários.

Para ter uma ideia do potencial do pacote vale olhar, por exemplo, a galeria de visualizações do Cédric Scherer.

Relatórios e Apps

RMarkdown

Uma análise de dados, em geral, vira um de dois produtos: um relatório/artigo ou um aplicativo interativo. Novamente o R tem funcionalidades incríveis para ambos os objetivos. Existe um tipo de arquivo chamado RMarkdown que junto com o pacote knitr permite compilar um arquivo misto de Markdown e R em formato pdf, html, doc ou ppt.

Essa extensão é tão poderosa que não só é possível escrever um artigo científico com ela, mas também, um dashboard interativo, um livro inteiro, ou até um blog/site (este blog é escrito em RMarkdown).

Atualmente o formato do código é ainda mais flexível, permitindo misturar linguagens como R, Python, SQL e outras num mesmo arquivo. Um resumo das funcionalidades pode ser visto aqui.

Shiny

O pacote shiny tem se tornado cada vez mais potente nos últimos anos. Inicialmente, ele servia para montar dashboards relativamente simples, que permitiam ao usuário mais liberdade para explorar e montar suas próprias análises. Atualmente, tanto o pacote como as suas extensões melhoraram muito o seu potencial.

A galeria de apps do RStudio já está um pouco desatualizada, mas dá um sabor do que é possível fazer com shiny.

Alguns exemplos:

Radiant - Esta é, sem dúvida, uma das aplicações mais completas e impressionantes de Shiny, vale um post inteiro por si só.
Monitor de Covid
Anaálise do Perfil de Eleitor no Brasil

Quarto

Recentemente lançado, o quarto não é um pacote de R propriamente dito. O Quarto é como um RMarkdown turbinado, é um meio de publicar análises de dados com textos. De maneira geral o Quarto te permite:

Escrever e rodar análises de dados em R, python e julia
Publicar relatórios, dashboards, livros, sites, etc.
Publicar artigos científicos utilizando equações, citações, etc.

Para conhecer mais sobre o Quarto vale a pena checar o site. Como o Quarto foi desenvolvido pela Posit, que desenvolvou o RStudio a IDE mais popular de R, o Quarto e o R funcionam muito bem no RStudio.

Quero baixar tudo

# O tidyverse inclui a instalação do dplyr, tidyr, readr, stringr e outros
packs <- c(
  "data.table",
  "vroom",
  "tidyverse",
  "readxl",
  "haven",
  "jsonlite",
  "sf",
  "rio",
  "lubridate",
  "dbplyr",
  "odbc",
  "DBI",
  "knitr",
  "shiny",
  "quarto"
  )

install.packages(packs, repos = "https://vps.fmvz.usp.br/CRAN/")