R Academy · Lección

reduce(), accumulate() y walk()

Pliegue listas, cree resultados acumulativos y aplique efectos secundarios con walk().

Lección 3 de 413 pasos

reduce(), accumulate() y walk() es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 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.

Más allá de map() — Otros verbos de purrr

Aunque map() aplica una función de forma independiente a cada elemento, algunas tareas requieren operaciones que combinan elementos (reduce), acumulan resultados intermedios o aplican funciones únicamente para producir efectos secundarios (walk). purrr ofrece funciones específicas para cada caso.

library(purrr)

# Example: combining a list of numbers into a single value
nums <- list(1, 2, 3, 4, 5)

# We want: 1 + 2 + 3 + 4 + 5 = 15
# map() can't do this — it returns 5 separate results
# reduce() folds the list into one value
result <- reduce(nums, `+`)
cat('Sum via reduce:', result)

reduce() — Reducir una lista a un valor

reduce(.x, .f, .init) aplica .f de forma acumulativa a los elementos de .x, de izquierda a derecha, y reduce la lista a un único valor. reduce(list(a,b,c), f) calcula f(f(a,b),c).

library(purrr)

# reduce with max: find the overall maximum
values <- list(42, 17, 89, 55, 23)
result <- reduce(values, max)
cat('Maximum:', result, '\n')

# reduce with paste: concatenate strings
words <- list('The', 'quick', 'brown', 'fox')
reduce(words, paste)

reduce() con .init

El argumento .init proporciona un valor inicial (semilla). La primera llamada se convierte en f(.init, x[1]). Esto es esencial cuando la lista puede estar vacía (el resultado se reduce a .init) o cuando necesita un estado inicial específico.

library(purrr)

# Running count of elements matching a condition
data <- list(5, 12, 3, 18, 7, 15, 2)

# Count values greater than 10, starting from 0
reduce(data, function(count, x) count + (x > 10), .init = 0L)

# Also useful for string building:
reduce(c('A','B','C'), paste, sep='-', .init='START')

reduce() con data frames — Encadenamiento de joins

Uno de los usos más potentes de reduce() es combinar una lista de data frames. En lugar de escribir left_join(left_join(df1, df2), df3), use reduce(list_of_dfs, left_join, by='key').

library(purrr)
library(dplyr)

base_df <- data.frame(id=1:3, name=c('Alice','Bob','Carol'))
scores <- data.frame(id=1:3, score=c(85,90,78))
grades <- data.frame(id=1:3, grade=c('B','A','C'))
city <- data.frame(id=1:3, city=c('NYC','LA','Chicago'))

dfs <- list(base_df, scores, grades, city)

reduce(dfs, left_join, by='id')

accumulate() — Conservar los resultados intermedios

accumulate(.x, .f) funciona como reduce(), pero conserva todos los valores intermedios. Devuelve un vector (o una lista) de la misma longitud que la entrada y muestra el resultado acumulado después de cada paso.

library(purrr)

# Running sum — same as cumsum() but via accumulate
values <- c(100, 120, 95, 140, 160)
accumulate(values, `+`)

# Running maximum
accumulate(c(50, 52, 48, 55, 53, 58), max)

accumulate() para obtener resultados paso a paso

accumulate() resulta especialmente útil para seguir los pasos de un algoritmo, construir cadenas de caracteres carácter por carácter o cualquier proceso en el que desee inspeccionar cada estado intermedio, no solo el resultado final.

library(purrr)

# Compound interest step by step
principal <- 1000
rates <- c(0.05, 0.05, 0.05, 0.05, 0.05)  # 5% per year

accumulate(rates, function(balance, rate) {
  round(balance * (1 + rate), 2)
}, .init = principal)

walk() — Efectos secundarios sin valor de retorno

walk(.x, .f) aplica .f a cada elemento de .x únicamente para producir sus efectos secundarios (imprimir, escribir archivos o enviar mensajes). Devuelve .x de forma invisible, por lo que puede usarlo en un pipeline sin romper la cadena.

library(purrr)

# Print a summary for each dataset
datasets <- list(
  mtcars = mtcars[,1:3],
  iris = iris[,1:3]
)

walk(datasets, function(df) {
  cat('Rows:', nrow(df), '| Cols:', ncol(df),
      '| NAs:', sum(is.na(df)), '\n')
})

walk() en un pipeline

Como walk() devuelve .x de forma invisible, puede insertarlo en un pipeline de dplyr para registrar o imprimir resultados intermedios sin interrumpir el flujo. Considérelo un punto de inspección para depuración o registro.

library(purrr)
library(dplyr)

results <- list(
  East = data.frame(rep=c('A','B'), sales=c(100,120)),
  West = data.frame(rep=c('C','D'), sales=c(200,190))
)

# Log each region's data, then continue processing
region_totals <- results %>%
  walk(~cat('Processing:', nrow(.x), 'rows\n')) %>%
  map_dbl(~sum(.x$sales))

print(region_totals)

walk2() — Efectos secundarios con dos entradas

walk2(.x, .y, .f) es la versión de walk() para dos entradas. Un caso de uso clásico es escribir varios data frames en archivos, donde .x es la lista de data frames y .y es la lista de rutas de archivo.

library(purrr)

data_list <- list(
  east = data.frame(x=1:3, y=4:6),
  west = data.frame(x=7:9, y=10:12)
)

file_paths <- list(
  '/tmp/east_data.csv',
  '/tmp/west_data.csv'
)

# Write each data frame to its corresponding path
walk2(data_list, file_paths, function(df, path) {
  write.csv(df, path, row.names=FALSE)
  cat('Written:', path, '\n')
})

iwalk() — walk con índice

iwalk(.x, .f) funciona como walk(), pero pasa el nombre o el índice del elemento como segundo argumento, .y. Resulta práctico cuando necesita saber qué elemento está procesando en el efecto secundario.

library(purrr)

region_counts <- list(East=150, West=200, North=85, South=120)

# Print each region with its rank
iwalk(region_counts, function(count, name) {
  cat(name, ':', count, 'customers\n')
})

reduce_right() — Reducción de derecha a izquierda

reduce(.x, .f, .dir='backward') (o el obsoleto reduce_right()) aplica la función de derecha a izquierda: f(a, f(b, f(c, d))). Esto es importante para operaciones no conmutativas, como la resta o la construcción de cadenas.

library(purrr)

words <- c('fox','brown','quick','The')

# Left-to-right: 'The quick brown fox'
reduce(rev(words), paste)

# Right-to-left: same effect but starting from right
reduce(words, function(a, b) paste(b, a))

Comprobación rápida

¿Cuándo usaría walk() en lugar de map()?

Responde en la lección interactiva

Recapitulación: reduce, accumulate y walk

Conceptos clave de reduce, accumulate y walk:

reduce(.x, .f) — reduce una lista a un valor (de izquierda a derecha); .init establece el valor inicial
reduce(list_of_dfs, left_join) — patrón potente para encadenar joins
accumulate(.x, .f) — funciona como reduce, pero devuelve todos los resultados intermedios
walk(.x, .f) — aplica una función para producir efectos secundarios (imprimir, escribir o registrar); devuelve .x
walk2(.x, .y, .f) — walk con dos entradas (por ejemplo, data frame + ruta de archivo)
iwalk(.x, .f) — walk con el nombre del elemento como segundo argumento

library(purrr)
library(dplyr)

# reduce() joins a list of data frames, accumulate() shows interim states
monthly_sums <- c(100, 120, 95, 140, 160, 130)

cat('reduce (total):      ', reduce(monthly_sums, `+`), '\n')
cat('accumulate (running):', accumulate(monthly_sums, `+`), '\n')

# walk() for side-effect logging
results <- list(a=42, b=17, c=89)
walk(results, ~cat('Value:', .x, '\n'))

Gratis para empezar

Aprende R con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 43
Lecciones: 159

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «reduce(), accumulate() y walk()» es gratis?

Sí — el texto completo de «reduce(), accumulate() y walk()» 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 «reduce(), accumulate() y walk()»?

Pliegue listas, cree resultados acumulativos y aplique efectos secundarios con walk(). 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 3 de 4.

¿Cuánto tiempo toma la lección «reduce(), accumulate() y walk()»?

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

← Volver a R Academy