0Pricing
R Academy · Lektion

reduce(), accumulate() und walk()

Falten Sie Listen, erstellen Sie kumulative Ergebnisse und wenden Sie mit walk() Seiteneffekte an.

reduce(), accumulate() und walk() ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Über map() hinaus — Weitere purrr-Verben

Während map() eine Funktion unabhängig auf jedes Element anwendet, erfordern manche Aufgaben Operationen, die Elemente zusammenfassen (reduce), Zwischenergebnisse akkumulieren oder Funktionen ausschließlich für Nebeneffekte ausführen (walk). purrr stellt für jeden dieser Fälle eigene Funktionen bereit.

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() — Eine Liste auf einen Wert reduzieren

reduce(.x, .f, .init) wendet .f von links nach rechts kumulativ auf die Elemente von .x an und reduziert die Liste auf einen einzelnen Wert. reduce(list(a,b,c), f) berechnet 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() mit .init

Das Argument .init gibt einen Startwert (Initialwert) vor. Der erste Aufruf lautet dann f(.init, x[1]). Das ist besonders wichtig, wenn die Liste leer sein kann (das Ergebnis ist dann .init) oder wenn ein bestimmter Anfangszustand benötigt wird.

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() mit Data Frames — Joins verketten

Eine der leistungsfähigsten Anwendungen von reduce() ist das Verknüpfen einer Liste von Data Frames. Statt left_join(left_join(df1, df2), df3) zu schreiben, verwenden Sie 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() — Zwischenergebnisse behalten

accumulate(.x, .f) funktioniert ähnlich wie reduce(), behält jedoch alle Zwischenergebnisse. Die Funktion gibt einen Vektor (oder eine Liste) mit derselben Länge wie die Eingabe zurück und zeigt nach jedem Schritt das laufende Ergebnis.

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() für schrittweise Ergebnisse

accumulate() eignet sich besonders zum Nachvollziehen von Algorithmen, zum zeichenweisen Erstellen von Zeichenketten oder für alle Prozesse, bei denen Sie jeden Zwischenzustand untersuchen möchten und nicht nur das Endergebnis.

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() — Nebeneffekte ohne Rückgabewert

walk(.x, .f) wendet .f auf jedes Element von .x ausschließlich wegen seiner Nebeneffekte an (Ausgeben, Schreiben von Dateien, Senden von Nachrichten). Die Funktion gibt .x unsichtbar zurück, sodass Sie sie in einer Pipeline verwenden können, ohne die Kette zu unterbrechen.

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() in einer Pipeline

Da walk() .x unsichtbar zurückgibt, können Sie die Funktion in eine dplyr-Pipeline einfügen, um Zwischenergebnisse zu protokollieren oder auszugeben, ohne den Ablauf zu unterbrechen. Stellen Sie sich die Funktion als Prüfpunkt für Debugging oder Protokollierung vor.

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() — Nebeneffekte mit zwei Eingaben

walk2(.x, .y, .f) ist die Variante von walk() für zwei Eingaben. Ein typischer Anwendungsfall ist das Schreiben mehrerer Data Frames in Dateien, wobei .x die Liste der Data Frames und .y die Liste der Dateipfade ist.

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 mit Index

iwalk(.x, .f) funktioniert wie walk(), übergibt jedoch den Elementnamen (oder Index) als zweites Argument .y. Das ist praktisch, wenn Sie beim Nebeneffekt wissen müssen, welches Element gerade verarbeitet wird.

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() — Reduktion von rechts nach links

reduce(.x, .f, .dir='backward') (oder das veraltete reduce_right()) wendet die Funktion von rechts nach links an: f(a, f(b, f(c, d))). Das ist bei nichtkommutativen Operationen wie Subtraktion oder dem Erstellen von Zeichenketten relevant.

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

Kurzer Test

Wann würden Sie walk() anstelle von map() verwenden?

Zusammenfassung: reduce, accumulate, walk

Die wichtigsten Punkte zu reduce, accumulate und walk:

  • reduce(.x, .f) — reduziert eine Liste auf einen Wert (von links nach rechts); .init legt den Startwert fest
  • reduce(list_of_dfs, left_join) — leistungsfähiges Muster zum Verketten von Joins
  • accumulate(.x, .f) — funktioniert wie reduce, gibt aber alle Zwischenergebnisse zurück
  • walk(.x, .f) — wird für Nebeneffekte angewendet (Ausgeben, Schreiben, Protokollieren); gibt .x zurück
  • walk2(.x, .y, .f) — walk mit zwei Eingaben (z. B. Data Frame + Dateipfad)
  • iwalk(.x, .f) — walk mit dem Elementnamen als zweitem Argument
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'))

Häufig gestellte Fragen

Ist die Lektion „reduce(), accumulate() und walk()“ kostenlos?

Ja — der vollständige Text von „reduce(), accumulate() und walk()“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „reduce(), accumulate() und walk()“?

Falten Sie Listen, erstellen Sie kumulative Ergebnisse und wenden Sie mit walk() Seiteneffekte an. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „reduce(), accumulate() und walk()“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. map() und typisierte Varianten
  2. map2() und pmap() für mehrere Eingaben
  3. reduce(), accumulate() und walk()
  4. keep(), discard() und Listenfilterung
← Zurück zu R Academy