R Academy · Lektion

Fönsterfunktioner: lag, lead, cumsum

Beräkna löpande summor, förskjutningar och kumulativa aggregationer inom grupper.

Lektion 2 av 413 steg

Fönsterfunktioner: lag, lead, cumsum är en gratis lektion i R Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.

Vad är fönsterfunktioner?

Fönsterfunktioner beräknar värden i förhållande till den aktuella raden utan att reducera datan. Till skillnad från summarize() behåller de alla rader. I dplyr används fönsterfunktioner i mutate(), ofta efter 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() – värdet på föregående rad

lag(x, n=1) returnerar värdet från n rader före den aktuella raden. Den eller de första raderna blir NA. Funktionen passar utmärkt för att beräkna förändringar från en period till nästa.

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() – värdet på nästa rad

lead(x, n=1) returnerar värdet från n rader framför den aktuella raden. Den eller de sista raderna blir NA. Funktionen är användbar för att beräkna hur det aktuella värdet förhåller sig till framtida värden.

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() och cumprod()

cumsum(x) beräknar en löpande totalsumma (kumulativ summa). cumprod(x) beräknar den kumulativa produkten. Båda är funktioner i base-R som fungerar smidigt i 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() och cummin()

cummax(x) följer det löpande maximumvärdet – det högsta värdet som har observerats hittills. cummin(x) följer det löpande minimumvärdet. Dessa funktioner är användbara för att följa historiska toppar och bottnar samt analysera nedgångar.

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

Rangordning med row_number()

row_number() tilldelar varje rad en heltalsrang. När funktionen används efter group_by() rangordnas raderna inom varje grupp. Vid lika värden får raderna konsekutiva rangtal utifrån den ordning de förekommer i.

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() – dela in i grupper

ntile(x, n) delar upp datan i n ungefär lika stora grupper och returnerar gruppnumret (1 = lägst). Funktionen är användbar för att skapa kvartiler, deciler eller percentilgrupper.

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() – relativ position

percent_rank(x) returnerar rangordningen för varje värde som en andel mellan 0 och 1. Det minsta värdet får 0 och det största får 1. Funktionen visar var ett värde ligger i förhållande till alla andra.

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

Fönsterfunktioner i grupper

Alla fönsterfunktioner blir gruppmedvetna när de kombineras med group_by(). Varje grupp får sitt eget oberoende fönster – lag/lead går inte över gruppgränser, cumsum återställs per grupp och rangordningen sker inom gruppen.

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

Kombinera flera fönsterfunktioner

Du kan kedja flera fönsterfunktioner i ett enda anrop till mutate() för att skapa innehållsrika analyskolumner. Det gör pipelinen lättläst och undviker upprepade anrop till 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() med argumentet default

lag(x, n=1, default=NA) accepterar ett värde för default som fyller de inledande positionerna med NA. Det är användbart när du behöver en numerisk baslinje i stället för saknade värden i beräknade kolumner.

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

Snabbkontroll

Vad returnerar ntile(x, 4) för det minsta värdet i x?

Besvara frågan i den interaktiva lektionen

Repetition: fönsterfunktioner

Viktiga slutsatser om fönsterfunktioner i dplyr:

lag(x, n) – värdet n rader före den aktuella; lead(x, n) – värdet n rader framför den aktuella
cumsum() – löpande totalsumma; cumprod() – löpande produkt
cummax() / cummin() – löpande maximum / minimum
row_number() – heltalsrang inom gruppen
ntile(x, n) – dela in i n grupper (1 = lägst, n = högst)
percent_rank(x) – bråkbaserad rang mellan 0 och 1
Alla fönsterfunktioner är gruppmedvetna när de kombineras med 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 att börja

Lär dig R med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 43
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Fönsterfunktioner: lag, lead, cumsum” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Fönsterfunktioner: lag, lead, cumsum”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Fönsterfunktioner: lag, lead, cumsum”?

Beräkna löpande summor, förskjutningar och kumulativa aggregationer inom grupper. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig R Academy?

Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Fönsterfunktioner: lag, lead, cumsum”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här R Academy-lektionen?

Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Grupperade sammanfattningar och group_by()
Fönsterfunktioner: lag, lead, cumsum
Kopplingar mellan flera tabeller i dplyr
Tidy evaluation: {{ }} och .data

← Tillbaka till R Academy