0Pricing
R Academy · Lektion

Window-Funktionen: lag, lead, cumsum

Berechnen Sie laufende Summen, Verschiebungen und kumulative Aggregate innerhalb von Gruppen.

Window-Funktionen: lag, lead, cumsum ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Window Functions?

Window Functions berechnen Werte relativ zur aktuellen Zeile, ohne die Daten zusammenzufassen. Anders als summarize() behalten sie alle Zeilen bei. In dplyr werden Window Functions innerhalb von mutate() verwendet – häufig nach 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() – Wert der vorherigen Zeile

lag(x, n=1) gibt den Wert n Zeilen vor der aktuellen Zeile zurück. Für die erste(n) Zeile(n) wird NA zurückgegeben. Die Funktion eignet sich ideal zur Berechnung von Veränderungen gegenüber der vorherigen Periode.

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() – Wert der nächsten Zeile

lead(x, n=1) gibt den Wert n Zeilen nach der aktuellen Zeile zurück. Für die letzte(n) Zeile(n) wird NA zurückgegeben. Dies ist nützlich, um den aktuellen Wert mit zukünftigen Werten zu vergleichen.

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

cumsum(x) berechnet eine laufende Summe (kumulative Summe). cumprod(x) berechnet ein kumulatives Produkt. Beide Funktionen gehören zu Base R und funktionieren nahtlos innerhalb von 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() und cummin()

cummax(x) verfolgt das laufende Maximum – den bisher höchsten beobachteten Wert. cummin(x) verfolgt das laufende Minimum. Diese Funktionen eignen sich zur Beobachtung von Allzeithochs und -tiefs sowie zur Drawdown-Analyse.

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

Rangfolge mit row_number()

row_number() weist jeder Zeile einen ganzzahligen Rang zu. Nach group_by() wird der Rang innerhalb jeder Gruppe vergeben. Bei Gleichständen werden aufeinanderfolgende Ränge entsprechend der Reihenfolge ihres Auftretens vergeben.

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() – In Gruppen einteilen

ntile(x, n) teilt die Daten in n ungefähr gleich große Gruppen ein und gibt die Gruppennummer zurück (1 = niedrigster Wert). Dies ist nützlich, um Quartile, Dezile oder Perzentilgruppen zu erstellen.

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() – Relative Position

percent_rank(x) gibt den Rang jedes Werts als Anteil zwischen 0 und 1 zurück. Das Minimum erhält 0, das Maximum 1. So sehen Sie, wo ein Wert im Verhältnis zu allen anderen liegt.

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

Window Functions in Gruppen

Alle Window Functions berücksichtigen Gruppen, wenn sie mit group_by() kombiniert werden. Jede Gruppe erhält ein eigenes, unabhängiges Fenster – lag/lead überschreiten keine Gruppengrenzen, cumsum wird pro Gruppe zurückgesetzt und Rangfolgen werden innerhalb der Gruppe erstellt.

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

Mehrere Window Functions kombinieren

Sie können mehrere Window Functions in einem Aufruf von mutate() verketten, um aussagekräftige analytische Spalten zu erstellen. Dadurch bleibt Ihre Pipeline übersichtlich, und wiederholte Aufrufe von group_by() werden vermieden.

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() mit dem Argument default

lag(x, n=1, default=NA) akzeptiert einen Wert für default, der an den anfänglichen NA-Positionen eingesetzt wird. Das ist nützlich, wenn Sie in berechneten Spalten eine numerische Ausgangsbasis anstelle fehlender Werte benötigen.

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

Schnelltest

Was gibt ntile(x, 4) für den kleinsten Wert in x zurück?

Rückblick: Window Functions

Die wichtigsten Erkenntnisse zu Window Functions in dplyr:

  • lag(x, n) – Wert n Zeilen vor der aktuellen; lead(x, n) – Wert n Zeilen nach der aktuellen
  • cumsum() – laufende Summe; cumprod() – laufendes Produkt
  • cummax() / cummin() – laufendes Maximum / Minimum
  • row_number() – ganzzahliger Rang innerhalb der Gruppe
  • ntile(x, n) – in n Gruppen einteilen (1 = niedrigster, n = höchster Wert)
  • percent_rank(x) – Ranganteil zwischen 0 und 1
  • Alle Window Functions berücksichtigen Gruppen, wenn sie mit group_by() kombiniert werden
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()

Häufig gestellte Fragen

Ist die Lektion „Window-Funktionen: lag, lead, cumsum“ kostenlos?

Ja — der vollständige Text von „Window-Funktionen: lag, lead, cumsum“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Window-Funktionen: lag, lead, cumsum“?

Berechnen Sie laufende Summen, Verschiebungen und kumulative Aggregate innerhalb von Gruppen. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Window-Funktionen: lag, lead, cumsum“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Gruppierte Zusammenfassungen und group_by()
  2. Window-Funktionen: lag, lead, cumsum
  3. Joins über mehrere Tabellen in dplyr
  4. Tidy Evaluation: {{ }} und .data
← Zurück zu R Academy