0Pricing
R Academy · Leçon

Fonctions de fenêtre : lag, lead, cumsum

Calculez des totaux cumulés, des décalages et des agrégations cumulées au sein des groupes.

Fonctions de fenêtre : lag, lead, cumsum est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Que sont les fonctions de fenêtre ?

Les fonctions de fenêtre calculent des valeurs par rapport à la ligne actuelle sans réduire les données. Contrairement à summarize(), elles conservent toutes les lignes. Dans dplyr, les fonctions de fenêtre sont utilisées dans mutate(), souvent aprè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() — Valeur de la ligne précédente

lag(x, n=1) renvoie la valeur située n lignes avant la ligne actuelle. La ou les premières lignes prennent la valeur NA. Cette fonction est idéale pour calculer les évolutions d’une période à l’autre.

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() — Valeur de la ligne suivante

lead(x, n=1) renvoie la valeur située n lignes après la ligne actuelle. La ou les dernières lignes prennent la valeur NA. Cette fonction est utile pour comparer la valeur actuelle aux valeurs futures.

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

cumsum(x) calcule un total progressif (somme cumulée). cumprod(x) calcule le produit cumulatif. Ce sont toutes deux des fonctions de base de R qui fonctionnent directement dans 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() et cummin()

cummax(x) suit le maximum progressif — la valeur la plus élevée observée jusqu’à présent. cummin(x) suit le minimum progressif. Ces fonctions sont utiles pour suivre les plus hauts et les plus bas historiques ainsi que pour analyser les baisses.

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

Classement avec row_number()

row_number() attribue un rang entier à chaque ligne. Utilisée après group_by(), cette fonction établit le classement au sein de chaque groupe. Les valeurs ex æquo reçoivent des rangs consécutifs selon leur ordre d’apparition.

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() — Répartir en groupes

ntile(x, n) divise les données en n groupes de taille approximativement égale et renvoie le numéro du groupe (1 = valeurs les plus faibles). Cette fonction est utile pour créer des quartiles, des déciles ou des groupes de percentiles.

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() — Position relative

percent_rank(x) renvoie le rang de chaque valeur sous la forme d’une proportion comprise entre 0 et 1. La valeur minimale obtient 0 et la valeur maximale obtient 1. Cette fonction indique la position d’une valeur par rapport à toutes les autres.

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

Fonctions de fenêtre dans les groupes

Toutes les fonctions de fenêtre tiennent compte des groupes lorsqu’elles sont associées à group_by(). Chaque groupe dispose de sa propre fenêtre indépendante : les fonctions lag/lead ne franchissent pas les limites des groupes, cumsum est réinitialisée pour chaque groupe et les classements sont établis au sein du groupe.

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

Combiner plusieurs fonctions de fenêtre

Vous pouvez enchaîner plusieurs fonctions de fenêtre dans un même appel à mutate() pour créer des colonnes analytiques riches. Votre pipeline reste ainsi lisible et vous évitez de répéter les appels à 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() avec l’argument default

lag(x, n=1, default=NA) accepte une valeur default pour remplir les positions initiales contenant NA. Cette possibilité est utile lorsque vous avez besoin d’une référence numérique plutôt que de valeurs manquantes dans les colonnes calculées.

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

Vérification rapide

Que renvoie ntile(x, 4) pour la valeur minimale de x ?

Récapitulatif&nbsp;: fonctions de fenêtre

Points essentiels des fonctions de fenêtre dans dplyr :

  • lag(x, n) — valeur située n lignes avant la ligne actuelle ; lead(x, n) — valeur située n lignes après
  • cumsum() — total progressif ; cumprod() — produit progressif
  • cummax() / cummin() — maximum / minimum progressif
  • row_number() — rang entier au sein du groupe
  • ntile(x, n) — répartit en n groupes (1 = plus faible, n = plus élevé)
  • percent_rank(x) — rang fractionnaire entre 0 et 1
  • Toutes les fonctions de fenêtre tiennent compte des groupes lorsqu’elles sont associées à 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()

Questions Fréquemment Posées

La leçon « Fonctions de fenêtre : lag, lead, cumsum » est-elle gratuite ?

Oui — le texte complet de « Fonctions de fenêtre : lag, lead, cumsum » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions de fenêtre : lag, lead, cumsum » ?

Calculez des totaux cumulés, des décalages et des agrégations cumulées au sein des groupes. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Fonctions de fenêtre : lag, lead, cumsum » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Synthèses groupées et group_by()
  2. Fonctions de fenêtre : lag, lead, cumsum
  3. Jointures entre plusieurs tables dans dplyr
  4. Évaluation tidy : {{ }} et .data
← Retour à R Academy