• O conceito de Tidy Data (Dados Organizados) foi formalizado por Hadley Wickham.

• Um arquivo de dados organizado possui a seguinte estrutura:

  • Cada linha representa uma observação individual
  • Cada coluna representa uma variável específica
  • Cada célula contém um valor de uma variável para uma observação específica

• A Figura 1 ilustra o conceito de dados organizados visualmente.

• Adequação para Ferramentas: Formato de armazenamento de dados adequado para análise em linguagens (R/Python) e softwares de análise de dados.

• Consistência: Estrutura uniforme para todos os conjuntos de dados

• Facilidade para operações comuns:

  • Filtragem de observações
  • Seleção de variáveis
  • Criação de novas variáveis
  • Agregação de dados
  • Junção de múltiplas tabelas

Colunas contendo valores: Nomes de colunas contendo valores de uma ou mais variáveis.

• Ex: Colunas nomeadas com anos (2020, 2021, 2022)

| Empresa   | 2020    | 2021    | 2022    |
|-----------|---------|---------|---------|
| Empresa A | 350.000 | 425.000 | 510.000 |
| Empresa B | 780.000 | 815.000 | 840.000 |
| Empresa C | 540.000 | 490.000 | 620.000 |

| Empresa   | Ano  | Valor   |
|-----------|------|---------|
| Empresa A | 2020 | 350.000 |
| Empresa A | 2021 | 425.000 |
| Empresa A | 2022 | 510.000 |
| Empresa B | 2020 | 780.000 |
| Empresa B | 2021 | 815.000 |
| Empresa B | 2022 | 840.000 |
| Empresa C | 2020 | 540.000 |
| Empresa C | 2021 | 490.000 |
| Empresa C | 2022 | 620.000 |

Características:

• Cada variável está em uma coluna separada
• Cada observação está em uma linha
• Cada célula contém um valor único

Múltiplas variáveis em uma coluna: Uma coluna contendo mais de uma variável

• Ex: “Nome_Empresa (Ano)” combinando empresa e ano

| Nome_Empresa (Ano) | Receita       | Despesa       |
|--------------------|---------------|---------------|
| Empresa A (2020)   | R$ 350.000,00 | R$ 290.000,00 |
| Empresa A (2021)   | R$ 425.000,00 | R$ 320.000,00 |
| Empresa B (2020)   | R$ 780.000,00 | R$ 710.000,00 |
| Empresa B (2021)   | R$ 815.000,00 | R$ 735.000,00 |

• Não se deve usar unidades (R$ no caso) em arquivos para armazenamento de dados para análise.

Variáveis em linhas e colunas

• Ex: Planilha de desempenho onde ROE aparece como coluna, mas Lucro Líquido e outras variáveis aparecem nas linhas

| Empresa            | ROE (%)       | Liquidez Corrente |
|--------------------|---------------|-------------------|
| Empresa XYZ        | 15,2          | 1,8               |
| Lucro Líquido      | R$ 2.500.000  | -                 |
| Patrimônio Líquido | R$ 16.400.000 | -                 |
| Ativo Circulante   | -             | R$ 3.600.000      |
| Passivo Circulante | -             | R$ 2.000.000      |

Dados organizados viabilizam e facilitam a:

• Reprodutibilidade: Formato padronizado que outros pesquisadores podem entender e utilizar

• Visualizações avançadas: Estrutura ideal para a criação de diversos tipos de tabelas e gráficos.

• Análise econométrica: Adequação imediata para estudos e modelos econométricos em (regressão linear, painel, logit, probit etc.)

• O tidyr é um pacote do tidyverse para organizar dados desorganizados

• Seu nome vem de “tidy” (organizado) + “r” (R)

• Foi criado para facilitar a transformação de dados desorganizados em dados organizados (tidy data) para análise

• É muito útil para a preparação de dados na fase 3 do CRISP-DM (Preparação dos Dados)

• Permite que dados em formatos comuns de planilhas e relatórios sejam transformados em formatos adequados para análise e visualização

• Na prática, muitos dados corporativos estão em formatos desorganizados:

  • Relatórios trimestrais com várias colunas para cada período
  • Planilhas otimizadas para visualização humana, não para análise
  • Dados exportados de sistemas legados ou ERP

• O pacote tidyr permite transformar esses dados desorganizados em dados organizados, essenciais para as fases seguintes do CRISP-DM:

  • Fase 3: Preparação dos Dados ← estamos aqui!

• pivot_longer(): Converte dados do formato amplo (onde valores de uma ou mais variáveis são espalhadas por colunas) em um formato longo (onde cada variável está em uma única coluna).

  • Útil quando você precisa de de dados para análise ou visualização

  • Ex: Transformar colunas de trimestres (Q1, Q2, Q3, Q4) em uma única coluna “trimestre”

• Iremos estudar somente a função pivot_longer(), porque o foco deste módulo é a preparação de dados para análise.

• Mas há diversas outras funções úteis para a organização de dados:

• Quando você tem planilhas financeiras com colunas para diferentes períodos (meses, trimestres, anos)

• Quando você recebe planilhas Excel organizadas para visualização humana, mas não para análise de dados.

• Quando precisa combinar dados de diferentes fontes que estão em formatos incompatíveis.

• Quando precisa preparar dados para visualizações específicas com ggplot2 (gráficos de linhas, facetas, etc.)

• Quando realiza análises temporais e precisa converter entre formatos de data/hora.

• Aplicar a função pivot_longer() com seus parâmetros essenciais: cols, names_to e values_to

• Organizar/Transformar dados complexos extraindo múltiplas informações de colunas

• Integrar pivot_longer() em pipelines de análise com dplyr

• Implementar soluções para casos reais de análise de dados administrativos

• A função pivot_longer() converte dados do formato amplo (wide) para o formato longo (long)

• É muito útil quando as colunas contêm valores em vez de variáveis

• Geralmente, é o primeiro passo para transformar planilhas de negócios em dados organizados para análise (tidy data)

• A Figura 4 ilustra o uso desta função

A função tribble() (abreviação de “transposed tibble”) é uma forma elegante de criar pequenas tibbles/data frames para exemplos ou testes:

# Criando uma data frame com tribble() - "tibble transposta"
produtos <- tribble(
  ~codigo, ~produto, ~preco, # Nomes das colunas começam com ~
  "A123", "Notebook", 3500, # Cada linha é um registro
  "B456", "Smartphone", 1800, # Os valores são separados por vírgulas
  "C789", "Monitor", 950 # A formatação facilita a leitura
)

# Visualizando a data frame criada
produtos

# A tibble: 3 × 3
  codigo produto    preco
  <chr>  <chr>      <dbl>
1 A123   Notebook    3500
2 B456   Smartphone  1800
3 C789   Monitor      950

Vantagens da função tribble():

• Layout Visual: Cada linha do código corresponde a uma linha da data frame, tornando o código mais legível

• Especificação direta: Os nomes das colunas são definidos com ~ (til)

• Flexibilidade de tipos: Cada coluna pode conter diferentes tipos de dados

• Ideal para exemplos: Perfeita para criar pequenas data frames para demonstrações ou testes.

Esta função faz parte do pacote tibble, que é carregado automaticamente quando você carrega o tidyverse.

# Criando a data frame de exemplo
receitas <- tribble(
  ~produto, ~T1, ~T2, ~T3, ~T4,
  "Produto A", 50000, 55000, 60000, 65000,
  "Produto B", 30000, 32000, 35000, 37000,
  "Produto C", 20000, 22000, 25000, 27000
)

# Visualizando a data frame original (formato amplo/wide)
receitas

# A tibble: 3 × 5
  produto      T1    T2    T3    T4
  <chr>     <dbl> <dbl> <dbl> <dbl>
1 Produto A 50000 55000 60000 65000
2 Produto B 30000 32000 35000 37000
3 Produto C 20000 22000 25000 27000

Este formato é para apresentação, não para armazenamento e análise.

# Transformando para o formato longo usando pivot_longer
receitas_longas <- receitas %>%
  pivot_longer(
    cols = c("T1", "T2", "T3", "T4"), # colunas que serão valores da nova coluna
    names_to = "trimestre", # nome da nova coluna
    values_to = "receita" # nome de outra nova coluna
  )

# Visualizando o resultado (formato longo/long)
receitas_longas

# A tibble: 12 × 3
   produto   trimestre receita
   <chr>     <chr>       <dbl>
 1 Produto A T1          50000
 2 Produto A T2          55000
 3 Produto A T3          60000
 4 Produto A T4          65000
 5 Produto B T1          30000
 6 Produto B T2          32000
 7 Produto B T3          35000
 8 Produto B T4          37000
 9 Produto C T1          20000
10 Produto C T2          22000
11 Produto C T3          25000
12 Produto C T4          27000

Agora os dados estão organizados:

• Cada linha é uma observação (um produto em um trimestre)
• Cada coluna é uma variável (produto, trimestre, receita)
• Cada célula contém um único valor

# Criando a data frame com múltiplas métricas por trimestre
desempenho <- tribble(
  ~empresa, ~receita_T1, ~receita_T2, ~despesa_T1, ~despesa_T2,
  "Empresa A", 150000, 175000, 120000, 130000,
  "Empresa B", 250000, 270000, 200000, 220000,
  "Empresa C", 100000, 115000, 80000, 95000
)

# Visualizando a data frame original
desempenho

# A tibble: 3 × 5
  empresa   receita_T1 receita_T2 despesa_T1 despesa_T2
  <chr>          <dbl>      <dbl>      <dbl>      <dbl>
1 Empresa A     150000     175000     120000     130000
2 Empresa B     250000     270000     200000     220000
3 Empresa C     100000     115000      80000      95000

Este formato é ainda mais desorganizado, pois mistura três variáveis (receita, despesa e trimestre) nos nomes das colunas.

# Transformando para o formato longo usando pivot_longer com nomes separados
desempenho_longo <- desempenho %>%
  pivot_longer(
    cols = -empresa, # todas as colunas exceto "empresa"
    names_to = c("indicador", "trimestre"), # nomes das duas novas colunas
    names_sep = "_", # separador nos nomes das colunas
    values_to = "valor" # nome de nova coluna para receber os valores
  )

# Visualizando o resultado
desempenho_longo

# A tibble: 12 × 4
   empresa   indicador trimestre  valor
   <chr>     <chr>     <chr>      <dbl>
 1 Empresa A receita   T1        150000
 2 Empresa A receita   T2        175000
 3 Empresa A despesa   T1        120000
 4 Empresa A despesa   T2        130000
 5 Empresa B receita   T1        250000
 6 Empresa B receita   T2        270000
 7 Empresa B despesa   T1        200000
 8 Empresa B despesa   T2        220000
 9 Empresa C receita   T1        100000
10 Empresa C receita   T2        115000
11 Empresa C despesa   T1         80000
12 Empresa C despesa   T2         95000

Observação importante:

• Os nomes das colunas originais (receita_T1, receita_T2, etc.) são divididos pelo separador “_” em exatamente duas partes.

• A primeira parte (“receita” ou “despesa”) vai para a coluna “indicador” e a segunda parte (“T1” ou “T2”) vai para a coluna “trimestre”.

• Este é um padrão comum em dados financeiros: quando os nomes de colunas seguem um formato consistente com separadores, podemos extrair as informações contidas neles para criar novas variáveis.

# Exemplo mais gerenciável para slides
receita_trimestral <- tribble(
  ~empresa, ~`2022_T1_Receita`, ~`2022_T2_Receita`, ~`2023_T1_Receita`, ~`2023_T2_Receita`,
  "ABC Ltda", 1200000, 1350000, 1500000, 1620000,
  "XYZ S.A.", 2500000, 2700000, 2900000, 3100000
)

# Visualizando a data frame original
receita_trimestral

# A tibble: 2 × 5
  empresa  `2022_T1_Receita` `2022_T2_Receita` `2023_T1_Receita`
  <chr>                <dbl>             <dbl>             <dbl>
1 ABC Ltda           1200000           1350000           1500000
2 XYZ S.A.           2500000           2700000           2900000
# ℹ 1 more variable: `2023_T2_Receita` <dbl>

• Temos informações de ano e trimestre nos nomes das colunas

• O dplyr é um dos pacotes principais do tidyverse, criado por Hadley Wickham

• Seu nome vem de “data plier” (alicate para dados) - uma ferramenta para manipular dados

• Foi projetado seguindo a filosofia “tidy data” (dados organizados) - cada variável é uma coluna, cada observação é uma linha

• É escrito em C++ para performance otimizada

• Permite manipulação de dados de forma consistente, clara e encadeada

• O pacote dplyr é parte do tidyverse

• Enquanto os pacotes readr e readxl ajudam na importação de dados, o dplyr é especializado na manipulação de dados

• O dplyr foi otimizado para manipular sobre dados organizados, longos ou tidy data

• O dplyr trabalha com uma estrutura de dados de R que já conhecemos: data frames/tibbles

• As funções do dplyr foram projetadas para serem usadas com o operador pipe (%>%), que já vimos brevemente no relatório Junglivet

• Muitas vezes precisamos filtrar somente certas linhas (observações ) de uma data frame.

• Muitas vezes precisamos selecionar somente certas colunas (variáveis) de uma data frame.

• Muitas vezes precisamos agrupar os dados por uma determinada(s) variável(s) categórica.

• Muitas vezes precisamos calcular estatísticas descritivas para esses subconjuntos de dados (função summarize).

# Um pipeline de análise com dplyr
relatorio_expectativa <- gapminder %>%
  # Filtra apenas os dados de 2007
  filter(year == 2007) %>%
  # Agrupa por continente
  group_by(continent) %>%
  # Calcula estatísticas resumidas
  summarize(
    expectativa_media = mean(lifeExp),
    expectativa_minima = min(lifeExp),
    expectativa_maxima = max(lifeExp),
    num_paises = n()
  ) %>%
  # Ordena do maior para o menor
  arrange(desc(expectativa_media))

# Visualiza o resultado final
relatorio_expectativa

Este exemplo demonstra como um conjunto de funções do dplyr pode ser combinado para transformar dados brutos organizados em um relatório informativo com apenas algumas linhas de código.

No relatório Junglivet, já utilizamos algumas funções do dplyr:

# Trecho do relatório Junglivet
dados_destilaria_limpos <- dados_destilaria %>%
  # Remove a coluna MONTH
  select(-MONTH) %>%
  # Renomeia as colunas
  rename(
    dia = DAY,
    mestre_responsavel = MANUFACTURER,
    # ... outras colunas renomeadas
  ) %>%
  # Converte cada variável para seu tipo adequado
  mutate(
    dia = as.numeric(dia),
    # ... outras conversões
  ) %>%
  # Remove linhas com valores ausentes
  drop_na()

Agora vamos entender em detalhes cada uma dessas funções e como aplicá-las em diferentes contextos de análise de dados.

O pacote dplyr fornece uma série de funções muito úteis para manipular data frames de uma maneira que:

• reduz a probabilidade de cometer erros
• economiza digitação
• o código é mais legível e compreensível

Vamos aprender 5 das funções mais usadas do pacote dplyr,

Além disso, veremos como como usar o operador pipe (%>%) para combiná-las.

• O pacote gapminder da linguagem R contém uma data frame também chamada gapminder.

• A df gapminder fornece informações detalhadas sobre indicadores socioeconômicos reais de vários países ao longo do tempo.

• Este conjunto de dados é muito utilizado no ensino da linguagem R e de métodos estatísticos.

• Vamos utilizar a df gapminder para ilustrar as funções do pacote dplyr.

• Para acessar os dados gapminder, basta instalar e carregar o pacote gapminder:

# carrega os pacotes
library(tidyverse)
library(gapminder)

Para obter uma visão geral da estrutura da df gapminder, podemos usar a função glimpse do pacote dplyr:

# visualizando a estrutura dos dados
dplyr::glimpse(gapminder)

Rows: 1,704
Columns: 6
$ country   <fct> "Afghanistan", "Afghanistan", "Afghanistan", "Afghanistan", …
$ continent <fct> Asia, Asia, Asia, Asia, Asia, Asia, Asia, Asia, Asia, Asia, …
$ year      <int> 1952, 1957, 1962, 1967, 1972, 1977, 1982, 1987, 1992, 1997, …
$ lifeExp   <dbl> 28.801, 30.332, 31.997, 34.020, 36.088, 38.438, 39.854, 40.8…
$ pop       <int> 8425333, 9240934, 10267083, 11537966, 13079460, 14880372, 12…
$ gdpPercap <dbl> 779.4453, 820.8530, 853.1007, 836.1971, 739.9811, 786.1134, …

Podemos também inspecionar as primeiras 6 linhas da data frame com a função head:

head(gapminder)

# A tibble: 6 × 6
  country     continent  year lifeExp      pop gdpPercap
  <fct>       <fct>     <int>   <dbl>    <int>     <dbl>
1 Afghanistan Asia       1952    28.8  8425333      779.
2 Afghanistan Asia       1957    30.3  9240934      821.
3 Afghanistan Asia       1962    32.0 10267083      853.
4 Afghanistan Asia       1967    34.0 11537966      836.
5 Afghanistan Asia       1972    36.1 13079460      740.
6 Afghanistan Asia       1977    38.4 14880372      786.

A data frame gapminder contida no pacote de mesmo nome, possui 1704 linhas (observações) e 6 colunas (variáveis).

• A função select() permite escolher quais variáveis (colunas) você quer manter ou remover de uma data frame

• Enquanto select() trabalha com colunas (variáveis), filter() trabalha com linhas (observações),

• É essencial para simplificar seus dados, focando apenas nas variáveis relevantes para sua análise

Imagine que você é um analista financeiro internacional e precisa preparar um relatório sobre PIB:

# Seleciona apenas as variáveis relevantes para análise financeira
dados_financeiros <- gapminder %>%
  select(country, year, gdpPercap)

# Visualiza as primeiras linhas do resultado
head(dados_financeiros)

# A tibble: 6 × 3
  country      year gdpPercap
  <fct>       <int>     <dbl>
1 Afghanistan  1952      779.
2 Afghanistan  1957      821.
3 Afghanistan  1962      853.
4 Afghanistan  1967      836.
5 Afghanistan  1972      740.
6 Afghanistan  1977      786.

Interpretação: Este código seria equivalente a extrair apenas os dados financeiros relevantes (país, ano e PIB per capita) de uma grande base de dados para uma análise específica de desempenho econômico.

• Se quisermos remover apenas a variável continent, podemos usar a sintáxe abaixo e salvar o resultado em outro objeto:

variaveis_selecionadas <- select(gapminder, -continent)
variaveis_selecionadas

# A tibble: 1,704 × 5
   country      year lifeExp      pop gdpPercap
   <fct>       <int>   <dbl>    <int>     <dbl>
 1 Afghanistan  1952    28.8  8425333      779.
 2 Afghanistan  1957    30.3  9240934      821.
 3 Afghanistan  1962    32.0 10267083      853.
 4 Afghanistan  1967    34.0 11537966      836.
 5 Afghanistan  1972    36.1 13079460      740.
 6 Afghanistan  1977    38.4 14880372      786.
 7 Afghanistan  1982    39.9 12881816      978.
 8 Afghanistan  1987    40.8 13867957      852.
 9 Afghanistan  1992    41.7 16317921      649.
10 Afghanistan  1997    41.8 22227415      635.
# ℹ 1,694 more rows

• Nos slides anteriores, usamos a sintáxe ‘normal’ da linguagem R.

• Mas o ponto forte do dplyr está na combinação de várias funções usando o operador pipe %>%.

• Vamos analisar a gramática do uso de funções do dplyr combinadas com o operador %>%.

• Atalho para inserir o operador pipe: Ctrl + shift + M

• O operador pipe pode ser lido como “então” ou “em seguida”

• Fluxo da esquerda para a direita, similar à leitura natural

• Transforma:

funcao(dados, arg1, arg2)

em

dados %>% funcao(arg1, arg2)

Uma linha de montagem onde cada função faz uma operação nos dados

gapminder %>% # Pegue os dados gapminder, então...
  filter(year == 2007) %>% # Filtre para apenas o ano 2007, então...
  group_by(continent) %>% # Agrupe por continente, então...
  summarize( # Calcule resumos:
    mean(lifeExp), # expectativa de vida média
    sum(pop) # população total 
  )

• A função filter() permite filtrar subconjuntos de observações (linhas) que atendem determinadas condições ou critérios.

• É uma das funções mais utilizadas na análise de dados para criar subconjuntos específicos dos dados

• Pense nela como um “filtro” que deixa passar apenas as observações que atendem aos critérios que você definir

• Imagine que você tem uma planilha de vendas e quer analisar apenas as vendas:

  • de um produto específico
  • acima de determinado valor
  • em uma região específica
  • em um período específico

• A função filter() permite fazer essa filtragem de forma rápida e precisa

Imagine que a data frame gapminder representa dados de filiais de uma empresa multinacional:

# Filtra apenas países das Américas
# como se fossem filiais da região Américas

filiais_americas <- gapminder %>%
  filter(continent == "Americas")

# Visualiza as primeiras 6 linhas do resultado
head(filiais_americas)

# A tibble: 6 × 6
  country   continent  year lifeExp      pop gdpPercap
  <fct>     <fct>     <int>   <dbl>    <int>     <dbl>
1 Argentina Americas   1952    62.5 17876956     5911.
2 Argentina Americas   1957    64.4 19610538     6857.
3 Argentina Americas   1962    65.1 21283783     7133.
4 Argentina Americas   1967    65.6 22934225     8053.
5 Argentina Americas   1972    67.1 24779799     9443.
6 Argentina Americas   1977    68.5 26983828    10079.

Interpretação: Este filtro seria equivalente a selecionar apenas dados de filiais localizadas nas Américas para uma análise regional de desempenho.

Dica prática: Comece sempre pensando na pergunta de negócio, depois traduza para o código

Há duas maneiras principais de combinar condições:

# Método 1: Usando o operador & (E lógico) - equivalente ao método 1
europeus_2007_alt <- gapminder %>%
  filter(continent == "Europe" & year == 2007)

# Método 2: Usando o operador | (OU lógico)
europa_ou_asia <- gapminder %>%
  filter(continent == "Europe" | continent == "Asia")

Dica importante:

• Com & (“E” lógico) ambas as condições precisam ser TRUE para que a linha seja mantida

• Com | (“OU” lógico), apenas uma das condições precisa ser TRUE

# Países com alta expectativa de vida (maior que 80 anos)
alta_exp_vida <- gapminder %>%
  filter(lifeExp > 80)

# Países com PIB per capita abaixo de 500 dólares
baixo_pib <- gapminder %>%
  filter(gdpPercap < 500)

# Anos diferentes de 2002
nao_2002 <- gapminder %>%
  filter(year != 2002)

Utilize operadores relacionais para:

• Encontrar valores acima/abaixo de limites importantes
• Excluir períodos ou categorias específicas
• Identificar casos extremos ou outliers