R Academy · Lezione

Funzioni finestra: lag, lead, cumsum

Calcoli totali progressivi, scostamenti e aggregazioni cumulative all'interno dei gruppi.

Lezione 2 di 413 passaggi

Funzioni finestra: lag, lead, cumsum è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Che cosa sono le funzioni finestra?

Le funzioni finestra calcolano valori in relazione alla riga corrente senza ridurre i dati. A differenza di summarize(), mantengono tutte le righe. In dplyr, le funzioni finestra vengono usate all'interno di mutate(), spesso dopo 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() — Valore della riga precedente

lag(x, n=1) restituisce il valore di n righe precedente a quella corrente. La prima riga (o le prime righe) conterrà NA. È ideale per calcolare variazioni tra periodi consecutivi.

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() — Valore della riga successiva

lead(x, n=1) restituisce il valore di n righe successivo a quella corrente. L'ultima riga (o le ultime righe) conterrà NA. È utile per confrontare il valore corrente con quelli futuri.

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) calcola un totale progressivo (somma cumulativa). cumprod(x) calcola il prodotto cumulativo. Entrambe sono funzioni di R base che funzionano perfettamente all'interno di 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) tiene traccia del massimo progressivo, cioè del valore più alto osservato fino a quel momento. cummin(x) tiene traccia del minimo progressivo. Sono utili per monitorare i massimi e i minimi storici e per analizzare i drawdown.

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)
  )

Classificazione con row_number()

row_number() assegna un rango intero a ogni riga. Se usata dopo group_by(), assegna il rango all'interno di ciascun gruppo. I valori a pari merito ricevono ranghi consecutivi in base all'ordine di apparizione.

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() — Dividere in gruppi

ntile(x, n) divide i dati in n gruppi di dimensioni approssimativamente uguali e restituisce il numero del gruppo (1 = valore più basso). È utile per creare quartili, decili o gruppi percentili.

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() — Posizione relativa

percent_rank(x) restituisce il rango di ogni valore come proporzione compresa tra 0 e 1. Il minimo riceve 0, il massimo riceve 1. Indica la posizione di un valore rispetto a tutti gli altri.

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))

Funzioni finestra nei gruppi

Tutte le funzioni finestra diventano consapevoli dei gruppi quando vengono combinate con group_by(). Ogni gruppo ha la propria finestra indipendente: lag/lead non oltrepassano i confini dei gruppi, cumsum si azzera per ogni gruppo e le classifiche vengono calcolate all'interno del gruppo.

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)
  )

Combinare più funzioni finestra

Potete concatenare più funzioni finestra in una sola chiamata a mutate() per creare colonne analitiche ricche di informazioni. In questo modo la pipeline rimane leggibile ed evitate di ripetere le chiamate a 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() con l'argomento default

lag(x, n=1, default=NA) accetta un valore default con cui riempire le posizioni iniziali NA. È utile quando nelle colonne calcolate vi serve una base numerica invece di valori mancanti.

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 rapida

Che cosa restituisce ntile(x, 4) per il valore minimo di x?

Rispondi nella lezione interattiva

Riepilogo: funzioni finestra

Concetti chiave sulle funzioni finestra in dplyr:

lag(x, n) — valore di n righe precedente a quella corrente; lead(x, n) — valore di n righe successivo
cumsum() — totale progressivo; cumprod() — prodotto progressivo
cummax() / cummin() — massimo / minimo progressivo
row_number() — rango intero all'interno del gruppo
ntile(x, n) — suddivide in n gruppi (1 = più basso, n = più alto)
percent_rank(x) — rango frazionario compreso tra 0 e 1
Tutte le funzioni finestra diventano consapevoli dei gruppi quando vengono combinate con 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()

Gratis per iniziare

Impara R con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 43
Lezioni: 159

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Funzioni finestra: lag, lead, cumsum» è gratuita?

Sì — il testo completo di «Funzioni finestra: lag, lead, cumsum» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Funzioni finestra: lag, lead, cumsum»?

Calcoli totali progressivi, scostamenti e aggregazioni cumulative all'interno dei gruppi. Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Funzioni finestra: lag, lead, cumsum»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a R Academy