Evaluación ordenada: {{ }} y .data
Escriba funciones de dplyr que acepten nombres de columnas como argumentos de forma segura.
Evaluación ordenada: {{ }} y .data es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
El problema: programar con dplyr
dplyr utiliza evaluación no estándar (NSE): los nombres de las columnas se pasan sin comillas. Esto resulta práctico de forma interactiva, pero es más complicado al escribir funciones. ¿Cómo se pasa un nombre de columna como variable a una función de 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!')El operador de inclusión {{ }}
Dentro de una función, use {{ col_var }} (denominado «curly-curly» o «embrace») para pasar un nombre de columna que se evaluará en el contexto del data frame. Este es el enfoque recomendado para la mayoría de los casos de programación de funciones con 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){{ }} para nombres de columna en la salida
También puede usar {{ }} en el lado izquierdo de := para asignar nombres dinámicos a las columnas de salida. El operador := (operador walrus) permite usar nombres de variables a la izquierda de las asignaciones dentro de los verbos de 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)El pronombre .data
.data[['col_name']] permite seleccionar una columna mediante una variable de tipo cadena. Indica explícitamente a dplyr que busque la columna en el data frame actual. Es útil cuando los nombres de las columnas se tienen como cadenas de caracteres.
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() — Aplicar a varias columnas
across(cols, fns), dentro de mutate() o summarize(), aplica una función a varias columnas a la vez. Seleccione las columnas con auxiliares de 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() con funciones con nombre
Pase una lista con nombre de funciones a across() para calcular varias estadísticas por columna. Las columnas de salida reciben nombres con el formato col_fn. Use .names para personalizar el patrón de nombres.
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() en mutate()
Usar across() dentro de mutate() transforma varias columnas simultáneamente. Así se evita repetir la misma transformación para cada columna.
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() — Seleccionar columnas para operaciones
pick() (dplyr 1.1+) selecciona un subconjunto de columnas como un data frame pequeño, lo que resulta útil para pasarlo a funciones que esperan un data frame. Funciona dentro de mutate() y 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))
)Escribir funciones reutilizables de dplyr
Combinar {{ }}, .data[[]] y across() permite escribir potentes funciones reutilizables de análisis. El patrón clave consiste en aceptar nombres de columna como argumentos sin comillas (use {{ }}) o como cadenas (use .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)Auxiliares de selección tidy
Los auxiliares de tidyselect funcionan dentro de across(), select() y pick(): starts_with(), ends_with(), contains(), matches(), num_range(), where(predicate) y 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()
)Combinar patrones de tidy eval
Las funciones de dplyr del mundo real suelen combinar {{ }} para las variables de agrupación, across() para varias métricas y .data[[]] para nombres de columna en forma de cadena. Comprender cuándo usar cada patrón hace que el código sea flexible y correcto.
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')Comprobación rápida
Dentro de una función personalizada, ¿cuál es la forma correcta de pasar un nombre de columna como argumento sin comillas a dplyr?
Repaso: evaluación tidy
Ideas clave sobre la programación con dplyr:
{{ col }}— incluir argumentos de nombres de columna sin comillas en las funciones.data[['col_name']]— acceder a columnas mediante el nombre de una variable de tipo cadena:=, el operador walrus — usarlo con{{ }}o con cadenas glue para obtener nombres de salida dinámicosacross(cols, fns)— aplicar una o varias funciones a varias columnas a la vezpick(cols)— seleccionar columnas como un sub-data-frame para operaciones por fila- Auxiliares de 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)Preguntas frecuentes
¿La lección «Evaluación ordenada: {{ }} y .data» es gratis?
Sí — el texto completo de «Evaluación ordenada: {{ }} y .data» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Evaluación ordenada: {{ }} y .data»?
Escriba funciones de dplyr que acepten nombres de columnas como argumentos de forma segura. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Evaluación ordenada: {{ }} y .data»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Resúmenes agrupados y group_by()
- Funciones de ventana: lag, lead y cumsum
- Uniones entre varias tablas en dplyr
- Evaluación ordenada: {{ }} y .data