R Academy · Aula

Funções de janela: lag, lead, cumsum

Calcule totais acumulados, deslocamentos e agregações cumulativas dentro de grupos.

Funções de janela: lag, lead, cumsum é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O que são funções de janela?

Funções de janela calculam valores em relação à linha atual sem reduzir os dados. Ao contrário de summarize(), elas mantêm todas as linhas. No dplyr, as funções de janela são usadas dentro de mutate() — geralmente após group_by().

library(dplyr)

# Monthly revenue — we want to compare each month to previous
df <- data.frame(
  month = 1:6,
  revenue = c(100, 120, 95, 140, 160, 130)
)
print(df)

lag() — Valor da linha anterior

lag(x, n=1) retorna o valor de n linhas anterior à linha atual. A primeira linha (ou as primeiras linhas) será NA. É ideal para calcular variações entre períodos.

library(dplyr)

df <- data.frame(
  month = 1:6,
  revenue = c(100, 120, 95, 140, 160, 130)
)

df %>%
  mutate(
    prev_revenue = lag(revenue),
    change = revenue - lag(revenue),
    pct_change = round(100 * (revenue - lag(revenue)) / lag(revenue), 1)
  )

lead() — Valor da próxima linha

lead(x, n=1) retorna o valor de n linhas à frente da linha atual. A última linha (ou as últimas linhas) será NA. É útil para calcular como o valor atual se compara aos valores futuros.

library(dplyr)

df <- data.frame(
  month = 1:5,
  revenue = c(100, 120, 95, 140, 160)
)

df %>%
  mutate(
    next_month = lead(revenue),
    next_2_months = lead(revenue, n = 2),
    will_increase = revenue < lead(revenue)
  )

cumsum() e cumprod()

cumsum(x) calcula um total progressivo (soma cumulativa). cumprod(x) calcula o produto cumulativo. Ambas são funções básicas do R que funcionam perfeitamente dentro de mutate().

library(dplyr)

df <- data.frame(
  month = 1:6,
  revenue = c(100, 120, 95, 140, 160, 130)
)

df %>%
  mutate(
    running_total = cumsum(revenue),
    growth_factor = round(cumprod(1 + (revenue - 100) / 100), 3)
  )

cummax() e cummin()

cummax(x) acompanha o máximo progressivo — o maior valor encontrado até o momento. cummin(x) acompanha o mínimo progressivo. Essas funções são úteis para acompanhar máximas e mínimas históricas e analisar reduções.

library(dplyr)

df <- data.frame(
  day = 1:7,
  price = c(50, 52, 48, 55, 53, 58, 56)
)

df %>%
  mutate(
    all_time_high = cummax(price),
    all_time_low = cummin(price),
    drawdown_from_high = price - cummax(price)
  )

Classificação com row_number()

row_number() atribui uma classificação inteira a cada linha. Quando usada após group_by(), ela classifica dentro de cada grupo. Empates recebem classificações consecutivas com base na ordem de aparição.

library(dplyr)

sales <- data.frame(
  region = c('East','East','East','West','West','West'),
  rep = c('Alice','Bob','Carol','Dave','Eve','Frank'),
  revenue = c(200, 150, 180, 120, 190, 160)
)

sales %>%
  group_by(region) %>%
  mutate(rank = row_number(desc(revenue))) %>%
  arrange(region, rank)

ntile() — Dividindo em grupos

ntile(x, n) divide os dados em n grupos de tamanhos aproximadamente iguais e retorna o número do grupo (1 = menor). É útil para criar quartis, decis ou grupos de percentis.

library(dplyr)

df <- data.frame(
  customer = paste0('C', 1:10),
  spend = c(50, 200, 75, 300, 125, 450, 25, 175, 100, 350)
)

df %>%
  mutate(
    quartile = ntile(spend, 4),
    decile = ntile(spend, 10)
  ) %>%
  arrange(spend)

percent_rank() — Posição relativa

percent_rank(x) retorna a classificação de cada valor como uma proporção entre 0 e 1. O mínimo recebe 0 e o máximo recebe 1. A função informa a posição de um valor em relação a todos os outros.

library(dplyr)

df <- data.frame(
  student = c('Alice','Bob','Carol','Dave','Eve'),
  score = c(85, 92, 78, 95, 88)
)

df %>%
  mutate(
    pct_rank = round(percent_rank(score), 3),
    top_pct = round(1 - percent_rank(score), 3)
  ) %>%
  arrange(desc(score))

Funções de janela em grupos

Todas as funções de janela passam a considerar os grupos quando combinadas com group_by(). Cada grupo recebe sua própria janela independente — lag/lead não atravessam os limites dos grupos, cumsum é reiniciada por grupo e as classificações são feitas dentro do grupo.

library(dplyr)

df <- data.frame(
  product = c('A','A','A','B','B','B'),
  month = c(1,2,3,1,2,3),
  sales = c(100, 120, 110, 200, 180, 220)
)

df %>%
  group_by(product) %>%
  mutate(
    mom_change = sales - lag(sales),
    cumulative = cumsum(sales),
    rank_in_product = row_number(sales)
  )

Combinando várias funções de janela

Você pode encadear várias funções de janela em uma única chamada de mutate() para criar colunas analíticas completas. Isso mantém seu pipeline legível e evita chamadas repetidas de group_by().

library(dplyr)

stock <- data.frame(
  date = as.Date(c('2024-01-01','2024-01-02','2024-01-03',
                   '2024-01-04','2024-01-05')),
  close = c(150.2, 152.8, 149.5, 155.1, 157.3)
)

stock %>%
  mutate(
    prev_close = lag(close),
    daily_return = round((close / lag(close) - 1) * 100, 2),
    running_high = cummax(close),
    distance_from_high = round(close - cummax(close), 2)
  )

lag() com o argumento default

lag(x, n=1, default=NA) aceita um valor default para preencher as posições iniciais com NA. Isso é útil quando você precisa de uma referência numérica em vez de valores ausentes nas colunas calculadas.

library(dplyr)

df <- data.frame(
  week = 1:5,
  visitors = c(500, 620, 480, 700, 650)
)

df %>%
  mutate(
    prev_week = lag(visitors, default = 0),
    growth = visitors - lag(visitors, default = visitors[1])
  )

Verificação rápida

O que ntile(x, 4) retorna para o menor valor em x?

Recapitulação: funções de janela

Principais conclusões sobre funções de janela no dplyr:

lag(x, n) — valor n linhas antes da atual; lead(x, n) — valor n linhas à frente
cumsum() — total progressivo; cumprod() — produto progressivo
cummax() / cummin() — máximo / mínimo progressivo
row_number() — classificação inteira dentro do grupo
ntile(x, n) — divide em n grupos (1 = menor, n = maior)
percent_rank(x) — classificação fracionária entre 0 e 1
Todas as funções de janela consideram os grupos quando combinadas com group_by()

library(dplyr)

# Comprehensive window function example
data.frame(
  region = c('East','East','East','West','West','West'),
  month = c(1,2,3,1,2,3),
  sales = c(100, 130, 120, 200, 190, 210)
) %>%
  group_by(region) %>%
  mutate(
    mom_chg = sales - lag(sales),
    running_total = cumsum(sales),
    rank = row_number(desc(sales))
  ) %>%
  ungroup()

Perguntas Frequentes

A aula “Funções de janela: lag, lead, cumsum” é grátis?

Sim — o texto completo de “Funções de janela: lag, lead, cumsum” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Funções de janela: lag, lead, cumsum”?

Calcule totais acumulados, deslocamentos e agregações cumulativas dentro de grupos. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Funções de janela: lag, lead, cumsum”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy