0Pricing
R Academy · Leçon

Évaluation tidy : {{ }} et .data

Écrivez des fonctions dplyr qui acceptent des noms de colonnes comme arguments en toute sécurité.

Évaluation tidy : {{ }} et .data est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Le problème : programmer avec dplyr

dplyr utilise une évaluation non standard (NSE) : les noms de colonnes sont transmis sans guillemets. Cette approche est pratique pour les interactions, mais plus délicate lors de l’écriture de fonctions. Comment transmettre un nom de colonne comme variable à une fonction dplyr ?

library(dplyr)

df <- data.frame(x=1:5, y=c(2,4,6,8,10))

# Works fine interactively:
df %>% summarize(mean_x = mean(x))

# But what if 'x' is a variable?
col_name <- 'x'
# df %>% summarize(result = mean(col_name))  # WRONG! treats 'col_name' as column
cat('Need tidy evaluation to solve this!')

L’opérateur d’embrassement {{ }}

Dans une fonction, utilisez {{ col_var }} (appelé « curly-curly » ou « embrassement ») pour transmettre un nom de colonne qui sera évalué dans le contexte du cadre de données. Il s’agit de l’approche recommandée pour programmer la plupart des fonctions dplyr.

library(dplyr)

df <- data.frame(
  group = c('A','A','B','B'),
  sales = c(100, 120, 200, 180),
  costs = c(60, 70, 110, 90)
)

# Function using {{ }}
group_mean <- function(data, group_col, value_col) {
  data %>%
    group_by({{ group_col }}) %>%
    summarize(mean_val = mean({{ value_col }}), .groups = 'drop')
}

group_mean(df, group, sales)
group_mean(df, group, costs)

{{ }} pour les noms de colonnes en sortie

Vous pouvez également utiliser {{ }} à gauche de := pour nommer dynamiquement les colonnes de sortie. L’opérateur := (opérateur morse) permet d’utiliser des noms de variables à gauche des affectations dans les verbes dplyr.

library(dplyr)

df <- data.frame(a=1:4, b=c(2,4,6,8))

# Dynamic output column name
compute_mean <- function(data, col) {
  col_name <- paste0('mean_', deparse(substitute(col)))
  data %>% summarize('{col_name}' := mean({{ col }}))
}

compute_mean(df, a)
compute_mean(df, b)

Le pronom .data

.data[['col_name']] permet de sélectionner une colonne à l’aide d’une variable de type chaîne. Il indique explicitement à dplyr de rechercher la colonne dans le cadre de données courant. Cela est utile lorsque les noms de colonnes sont des chaînes de caractères.

library(dplyr)

df <- data.frame(
  name = c('Alice','Bob','Carol'),
  score = c(85, 92, 78),
  grade = c('B','A','C')
)

# Using .data with a string variable
get_summary <- function(data, col_name) {
  data %>%
    summarize(
      n = n(),
      mean_val = mean(.data[[col_name]])
    )
}

get_summary(df, 'score')

across() — Appliquer à plusieurs colonnes

across(cols, fns), utilisé dans mutate() ou summarize(), applique une fonction à plusieurs colonnes à la fois. Sélectionnez les colonnes avec les assistants tidyselect : starts_with(), where(is.numeric), everything(), etc.

library(dplyr)

df <- data.frame(
  id = 1:3,
  sales_q1 = c(100, 200, 150),
  sales_q2 = c(120, 180, 160),
  cost_q1 = c(60, 110, 80),
  cost_q2 = c(70, 100, 85)
)

# Summarize all numeric columns except 'id'
df %>%
  summarize(across(where(is.numeric) & !id, mean))

across() avec des fonctions nommées

Transmettez une liste nommée de fonctions à across() pour calculer plusieurs statistiques par colonne. Les colonnes de sortie sont nommées selon le modèle col_fn. Utilisez .names pour personnaliser le modèle de nommage.

library(dplyr)

df <- data.frame(
  x = c(10, 20, 30, 40),
  y = c(5, 15, 25, 35)
)

# Compute mean and sd for both columns
df %>%
  summarize(across(
    c(x, y),
    list(mean = mean, sd = sd),
    .names = '{.col}_{.fn}'
  ))

across() dans mutate()

L’utilisation de across() dans mutate() transforme simultanément plusieurs colonnes. Cela évite de répéter la même transformation pour chaque colonne.

library(dplyr)

df <- data.frame(
  id = 1:3,
  revenue = c(1000, 2000, 1500),
  cost = c(600, 1100, 800),
  tax = c(100, 200, 150)
)

# Round all numeric columns except id to nearest 10
df %>%
  mutate(across(where(is.numeric) & !id,
                ~round(., -2)))

pick() — Sélectionner des colonnes pour des opérations

pick() (dplyr 1.1+) sélectionne un sous-ensemble de colonnes sous la forme d’un mini-cadre de données, ce qui est utile pour le transmettre à des fonctions qui attendent un cadre de données. Cette fonction s’utilise dans mutate() et summarize().

library(dplyr)

df <- data.frame(
  id = 1:3,
  a = c(1, 2, 3),
  b = c(4, 5, 6),
  c_val = c(7, 8, 9)
)

# Use pick() to compute row-wise mean across selected columns
df %>%
  mutate(
    row_mean = rowMeans(pick(a, b, c_val)),
    row_max = do.call(pmax, pick(a, b, c_val))
  )

Écrire des fonctions dplyr réutilisables

La combinaison de {{ }}, .data[[]] et across() permet d’écrire de puissantes fonctions d’analyse réutilisables. Le principe essentiel : accepter les noms de colonnes comme arguments sans guillemets (avec {{ }}) ou comme chaînes (avec .data[[]]).

library(dplyr)

df <- data.frame(
  region = c('East','East','West','West'),
  product = c('A','B','A','B'),
  revenue = c(100, 200, 150, 250),
  units = c(10, 15, 12, 20)
)

# Flexible grouped summary function
group_stats <- function(data, ..., metric) {
  data %>%
    group_by(...) %>%
    summarize(
      total = sum({{ metric }}),
      average = mean({{ metric }}),
      .groups = 'drop'
    )
}

group_stats(df, region, metric = revenue)
group_stats(df, region, product, metric = units)

Assistants de sélection tidy

Les assistants tidyselect fonctionnent dans across(), select() et pick() : starts_with(), ends_with(), contains(), matches(), num_range(), where(predicate) et everything().

library(dplyr)

df <- data.frame(
  id = 1:3,
  score_2022 = c(80,85,90),
  score_2023 = c(82,88,91),
  score_2024 = c(85,90,93),
  category = c('A','B','A')
)

# Select all score columns and compute their means
df %>%
  summarize(
    across(starts_with('score'), mean),
    n = n()
  )

Combiner les approches d’évaluation tidy

Les fonctions dplyr utilisées dans des situations réelles combinent souvent {{ }} pour les variables de groupe, across() pour plusieurs indicateurs et .data[[]] pour les noms de colonnes sous forme de chaînes. Comprendre quand utiliser chaque approche rend votre code flexible et correct.

library(dplyr)

df <- data.frame(
  dept = c('HR','HR','Eng','Eng'),
  salary = c(60000, 65000, 100000, 110000),
  bonus = c(5000, 6000, 15000, 18000)
)

# String-based column selection with .data
summarize_column <- function(data, group_col, value_col_name) {
  data %>%
    group_by(.data[[group_col]]) %>%
    summarize(
      mean = mean(.data[[value_col_name]]),
      total = sum(.data[[value_col_name]]),
      .groups = 'drop'
    )
}

summarize_column(df, 'dept', 'salary')
summarize_column(df, 'dept', 'bonus')

Vérification rapide

Dans une fonction personnalisée, quelle est la bonne manière de transmettre un nom de colonne comme argument sans guillemets à dplyr ?

Récapitulatif&nbsp;: évaluation tidy

Points essentiels pour programmer avec dplyr :

  • {{ col }} — intégrer dans les fonctions les noms de colonnes transmis sans guillemets
  • .data[['col_name']] — accéder aux colonnes à partir du nom d’une variable chaîne
  • :=, opérateur morse — à utiliser avec {{ }} ou des chaînes interpolées pour nommer dynamiquement les sorties
  • across(cols, fns) — appliquer une ou plusieurs fonctions à plusieurs colonnes à la fois
  • pick(cols) — sélectionner des colonnes sous forme de sous-cadre de données pour des opérations ligne par ligne
  • Assistants tidyselect : starts_with(), where(), contains(), everything()
library(dplyr)

df <- data.frame(
  group = c('A','A','B','B'),
  v1 = c(10, 20, 30, 40),
  v2 = c(5, 15, 25, 35)
)

# Reusable function using {{ }} + across
group_summary <- function(data, grp) {
  data %>%
    group_by({{ grp }}) %>%
    summarize(across(where(is.numeric), list(mean=mean, sum=sum)), .groups='drop')
}

group_summary(df, group)

Questions Fréquemment Posées

La leçon « Évaluation tidy : {{ }} et .data » est-elle gratuite ?

Oui — le texte complet de « Évaluation tidy : {{ }} et .data » 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 « Évaluation tidy : {{ }} et .data » ?

Écrivez des fonctions dplyr qui acceptent des noms de colonnes comme arguments en toute sécurité. 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 4 sur 4.

Combien de temps prend la leçon « Évaluation tidy : {{ }} et .data » ?

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