如何使用lapply定义多个变量？多变量列表函数应用技术问询

Hey there! Let's figure out how to apply a multi-variable function to a list when you're used to single-variable lapply() workflows. I'll walk through examples, fix common missteps, and even add a benchmark to compare approaches.

First, Let's Define Our Scenario & Expected Output #

Let's start with a concrete example so we know what we're aiming for. Suppose:

• We have a list of numeric vectors: my_list <- list(a = 1:3, b = 4:6, c = 7:9)
• We want to apply a function that takes two arguments, like adding a specific value to each list element: add_n <- function(x, y) x + y
• We have a corresponding vector of values to add: y_vals <- c(2, 3, 4)

Manual Expected Output:

$a
[1] 3 4 5

$b
[1] 7 8 9

$c
[1] 11 12 13

Common Misstep: Trying to Pass Two Variables Directly to lapply() #

If you tried something like lapply(my_list, add_n, x = my_list, y = y_vals), you probably got errors because lapply() only iterates over one input at a time. The trick is to either use a function that handles multiple inputs, or wrap your function in an anonymous call.

Solutions for Multi-Variable List Application #

1. Use mapply() (Base R's Multi-Variable Apply)

Since you mentioned sapply() is more intuitive for you, mapply() is its multi-variable counterpart—it iterates over multiple inputs in parallel. Just make sure to set SIMPLIFY = FALSE to keep the output as a list (otherwise it might collapse to a matrix/vector if possible):

my_list <- list(a = 1:3, b = 4:6, c = 7:9)
y_vals <- c(2, 3, 4)
add_n <- function(x, y) x + y

# Get the expected list output
mapply(add_n, my_list, y_vals, SIMPLIFY = FALSE)

2. Wrap in an Anonymous Function with lapply()

If you really want to stick with lapply(), you can iterate over the indices of your list, then pull the corresponding elements from both the list and your second variable:

result <- lapply(seq_along(my_list), function(i) {
  add_n(my_list[[i]], y_vals[i])
})
# Optional: Name the output to match the original list
names(result) <- names(my_list)

3. Use Map() (A Wrapper for mapply(SIMPLIFY = FALSE))

Map() is a simpler wrapper that defaults to returning a list, so it's great if you don't want to remember the SIMPLIFY argument:

Map(add_n, my_list, y_vals)

Benchmarking the Approaches #

Let's test which method is fastest with larger data using the microbenchmark package. This helps you choose the right approach for big datasets:

library(microbenchmark)

# Create larger test data
big_list <- replicate(1000, sample(1:100, 50), simplify = FALSE)
y_big <- sample(1:100, 1000, replace = TRUE)

# Define our function
add_n <- function(x, y) x + y

# Run benchmark (100 iterations)
bench_results <- microbenchmark(
  mapply_method = mapply(add_n, big_list, y_big, SIMPLIFY = FALSE),
  lapply_anonymous = lapply(seq_along(big_list), function(i) add_n(big_list[[i]], y_big[i])),
  Map_method = Map(add_n, big_list, y_big),
  times = 100
)

# Print results
print(bench_results)

Typically, Map() and mapply() will outperform the anonymous lapply() approach because they avoid manual index lookup. For small datasets, the difference is negligible, but for large lists, it can add up.

内容的提问来源于stack exchange，提问作者jay.sf