R Academy · Aula

reduce(), accumulate() e walk()

Dobre listas, crie resultados cumulativos e aplique efeitos colaterais com walk().

Aula 3 de 413 etapas

reduce(), accumulate() e walk() é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Além de map() — Outros verbos do purrr

Embora map() aplique uma função independentemente a cada elemento, algumas tarefas exigem operações que combinam elementos (reduce), acumulam resultados intermediários ou aplicam funções exclusivamente para obter efeitos colaterais (walk). O purrr oferece funções 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() — Reduzindo uma lista a um valor

reduce(.x, .f, .init) aplica .f cumulativamente aos elementos de .x, da esquerda para a direita, reduzindo a lista a um ú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() com .init

O argumento .init fornece um valor inicial (semente). A primeira chamada torna-se f(.init, x[1]). Isso é essencial quando a lista pode estar vazia (caso em que o resultado é .init) ou quando é necessário um 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() com quadros de dados — Encadeando junções

Um dos usos mais poderosos de reduce() é unir uma lista de quadros de dados. Em vez de escrever 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() — Mantendo os resultados intermediários

accumulate(.x, .f) é semelhante a reduce(), mas mantém todos os valores intermediários. Retorna um vetor (ou lista) com o mesmo comprimento da entrada, mostrando o resultado acumulado após cada etapa.

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 resultados passo a passo

accumulate() é especialmente útil para rastrear as etapas de um algoritmo, construir textos caractere por caractere ou qualquer processo em que se queira inspecionar cada estado intermediário, e não apenas o 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() — Efeitos colaterais sem retorno

walk(.x, .f) aplica .f a cada elemento de .x exclusivamente por causa de seus efeitos colaterais (exibir, gravar arquivos ou enviar mensagens). Retorna .x de forma invisível, para que possa ser usado em um fluxo de processamento sem interromper a cadeia.

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() em um fluxo de processamento

Como walk() retorna .x de forma invisível, você pode inseri-lo em um fluxo de processamento do dplyr para registrar ou exibir resultados intermediários sem interromper o fluxo. Pense nele como um ponto de inspeção para depuração ou 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() — Efeitos colaterais com duas entradas

walk2(.x, .y, .f) é a versão de walk() com duas entradas. Um caso de uso clássico é gravar vários quadros de dados em arquivos, em que .x é a lista de quadros de dados e .y é a lista de caminhos de arquivos.

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 com índice

iwalk(.x, .f) é semelhante a walk(), mas passa o nome (ou índice) do elemento como segundo argumento, .y. Isso é conveniente quando é necessário saber qual elemento está sendo processado no efeito colateral.

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() — Redução da direita para a esquerda

reduce(.x, .f, .dir='backward') (ou o obsoleto reduce_right()) aplica a função da direita para a esquerda: f(a, f(b, f(c, d))). Isso é importante para operações não comutativas, como subtração ou construção de textos.

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

Verificação rápida

Quando você usaria walk() em vez de map()?

Responda na aula interativa

Recapitulação: reduce, accumulate, walk

Principais pontos sobre reduce, accumulate e walk:

reduce(.x, .f) — reduz uma lista a um valor (da esquerda para a direita); .init define o valor inicial
reduce(list_of_dfs, left_join) — padrão poderoso para encadear junções
accumulate(.x, .f) — semelhante a reduce, mas retorna todos os resultados intermediários
walk(.x, .f) — aplica a função para obter efeitos colaterais (exibir, gravar, registrar); retorna .x
walk2(.x, .y, .f) — walk com duas entradas (por exemplo, quadro de dados + caminho de arquivo)
iwalk(.x, .f) — walk com o nome do 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'))

Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 43
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “reduce(), accumulate() e walk()” é grátis?

Sim — o texto completo de “reduce(), accumulate() e walk()” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “reduce(), accumulate() e walk()”?

Dobre listas, crie resultados cumulativos e aplique efeitos colaterais com walk(). Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “reduce(), accumulate() e walk()”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy