R lapply() function is used to apply the function to each element of a list or a vector and return a list of the same length as the input. It is part of the apply family of functions that provide a flexible approach to iteration over data structures. By using lapply(), you can perform operations on complex data structures without the need for explicit loops, leading to cleaner and more efficient code. This function is particularly useful for applying custom functions or built-in functions to elements of a data frame, list, or vector.
In this article, I will explain the lapply() function, including its syntax, parameters, and usage, and demonstrate how to apply this function to each element of a vector or list and each column of a data frame through multiple examples.
Key points-
lapplyapplies a specified function to each element of a list, vector, or data frame and returns a list.- Regardless of the input type, lapply always returns a list.
- Custom functions with multiple arguments can be used with
lapplyby passing additional arguments through the...parameter. - Using
lapplysimplifies code by reducing the need for explicit loops, making the code more readable and concise. - Anonymous functions can be used directly within
lapplyfor simple operations, avoiding the need to define separate functions. sapplyis similar tolapplybut attempts to simplify the result to the lowest possible dimension, such as a vector or matrix, if possible.- lapply can be nested to handle multi-dimensional data structures, applying functions recursively to elements within lists of lists.
- When applied to data frames, lapply operates on columns as lists, making it useful for column-wise operations like calculating lengths, means, or applying transformations.
- Built-in R functions can also be used with
lapply(), making it a powerful tool for a wide range of operations.
lapply() Function
The lapply() function iterates over each element of the input list or vector, applies the specified function to each element, and returns the results in a new list. This function is closely related to other apply functions like sapply() and vapply(). However, lapply() always returns a list, while sapply() attempts to simplify the result to a vector or matrix, and vapply() allows for specifying the return type.
Syntax of lapply()
Following is the syntax of the lappy() Function.
# Syntax of lapply() function
lapply(list, FUN, ....)
Parameters
X: A vector (atomic or list) or an expression object.FUN: The function to be applied to each element ofX....: Additional arguments to be passed toFUN.
Return Value
It returns a list of the same length as the input.
Use lapply() Function to R Data Frame
When you use the lapply() function to apply a specified function to a data frame, it will be applied to all elements in the data frame. Let’s create a data frame and pass it to lapply() along with the specified function to obtain a result in the form of a list, with the same length as the input.
# Use lapply() function to data frame
df <- data.frame(Names = c("Ram", "Varun", "Tej"))
print("Given data frame:")
print(df)
print("Get the type of df:")
print(class(df))
result <- lapply(df, nchar)
print("After applying the function to df")
print(result)
print("Get the type of result:")
print(class(result))
Yields below output.
Use lapply() Function to R Vector
You can also utilize lapply on a vector to apply a function to each element. Simply pass the vector and the specified function to lapply to obtain the desired result in a list, maintaining the same length as the input vector.
# Use lapply() function to vector
vec <- c("Ram", "Varun", "Tej")
print("Given vector:")
print(vec)
print("Get the type of vec:")
print(class(vec))
result <- lapply(vec, toupper)
print("After applying the function to vector")
print(result)
print("Get the type of result:")
print(class(result))
Yoelds below output.
lapply() with Multiple Arguments in R
Alternatively, you can use the lapply() with multiple arguments by defining a custom function that takes multiple parameters. First, define a vector and create a custom function that adds a specific feature to each element. When lapply() is applied to the vector using this function, it iterates over each element, producing a list of modified elements.
lapply() with multiple arguments
# Define the vector
vec <- c("Ram", "Varun", "Tej")
# Define a custom function that takes multiple arguments
add_suffix <- function(name, suffix) {
return(paste(name, suffix, sep = "_"))
}
# Define the suffix
suffix <- "2024"
# Use lapply with the custom function and additional arguments
result <- lapply(vec, add_suffix, suffix = suffix)
print("After applying the function to vector:")
print(result)
print("Get the type of result:")
print(class(result))
Yields below output.
# Output:
[1] "After applying the function to vector:"
> print(result)
[[1]]
[1] "Ram_2024"
[[2]]
[1] "Varun_2024"
[[3]]
[1] "Tej_2024"
[1] "Get the type of result:"
[1] "list"
lapply with a Custom Function
You can use the lapply() function with a custom function to perform a specific operation on each element of a vector. First, define a custom function that performs the desired operation on each number, and then apply this function to a vector of numbers using lapply().
# lapply with custom function
# Create the vector of numbers
num_vec <- c(1, 2, 3, 4, 5)
# Create a custom function that calculates the square of a number
square <- function(x) {
return(x^2)
}
# Use lapply with the custom function
result <- lapply(numbers, square)
print("Given vector:")
print(num_vec)
print("After applying the custom function to vector:")
print(result)
print("Get the type of result:")
print(class(result))
Yields below output.
# Output:
[1] "Given vector:"
[1] 1 2 3 4 5
[1] "After applying the custom function to vector:"
[[1]]
[1] 1
[[2]]
[1] 4
[[3]]
[1] 9
[[4]]
[1] 16
[[5]]
[1] 25
[1] "Get the type of result:"
[1] "list"
Difference between lapply and For Loop
The lapply() function and for loops are both used for iterating over elements in R, but they have some key differences in terms of usage and efficiency.
lapply() is a functional programming tool that applies a given function to each element of a list or vector and returns a list. Using lapply() often results in more concise and readable code compared to a for loop, particularly for simple operations. It consistently returns a list, regardless of the input type.
Whereas for loop is a more general control flow statement that allows for explicit iteration over elements, providing more flexibility for complex logic.
Let’s create a numeric vector and use both the lapply() function and a for loop to implement a squaring function. We’ll observe the differences between the two approaches.
Using the lapply() function, you can apply a squaring function to each element in a vector, resulting in a list that contains the squares of the numbers in the vector.
# Define the vector of numbers
num_vec <- c(1, 2, 3, 4, 5)
# Use lapply to calculate the square of each number
result <- lapply(numbers, function(x) x^2)
print("After applying function to vector:")
print(result)
print("Get the type of result:")
print(class(result))
Yields below output.
# Output:
[1] "After applying function to vector:"
[[1]]
[1] 1
[[2]]
[1] 4
[[3]]
[1] 9
[[4]]
[1] 16
[[5]]
[1] 25
[1] "Get the type of result:"
[1] "list"
It provides more concise and readable code compared to a for loop
You can use a for loop to obtain the squares of a given numeric vector. First, create a numeric vector, initialize an empty list to store the squared numbers, and then use a for loop to calculate the square of each number in the vector. This step-by-step process increases the code’s clarity and structure.
# Define the vector of numbers
num_vec <- c(1, 2, 3, 4, 5)
# Create an empty list to store the squared numbers
result <- vector("list", length(num_vec))
# Use a for loop to calculate the square of each number
for (i in seq_along(num_vec)) {
result[[i]] <- num_vec[i]^2
}
print("Get the result using for loop:")
print(result)
print("Get the type of result:")
print(class(result))
Yields below output.
# Output:
[1] "Get the result using for loop:"
[[1]]
[1] 1
[[2]]
[1] 4
[[3]]
[1] 9
[[4]]
[1] 16
[[5]]
[1] 25
[1] "Get the type of result:"
[1] "list"
Difference between lapply and sapply
Both lapply and sapply are used to apply a function to each element of a list or vector in R. However, they differ in their return types.
lapply applies a function to each element of a list or vector and always returns a list, regardless of the original input’s type.
sapply is a user-friendly version of lapply. It attempts to simplify the result into a vector or matrix if possible. If the result can’t be simplified, it returns a list.
Let’s observe the return values when we apply both methods to each element of a numeric vector and compare their outputs.
# Define the vector of numbers
num_vec <- c(1, 2, 3, 4, 5)
# Use lapply to calculate the square of each number
result <- sapply(numbers, function(x) x^2)
print("After applying function to vector:")
print(result)
print("Get the type of result:")
print(class(result))
Yields below output.
# Output:
[1] "After applying function to vector:"
[1] 1 4 9 16 25
[1] "Get the type of result:"
[1] "numeric"
Nested lapply Function
Using nested lapply functions can be particularly useful when dealing with multi-dimensional data structures, such as lists of lists.
Let’s create a list of lists, where each sublist contains numbers, and then use nested lapply to square each number within each sublist.
# Define a list of lists
nested_list <- list(
list(1, 2, 3),
list(4, 5, 6)
)
print("Original nested list:")
print(nested_list)
# Use nested lapply to calculate the square of each number in each sublist
result <- lapply(nested_list, function(inner_list) {
lapply(inner_list, function(x) x^2)
})
print("After applying nested lapply function to nested list:")
print(result)
Yields below output.
# Output:
[1] "After applying nested lapply function to nested list:"
[[1]]
[[1]][[1]]
[1] 1
[[1]][[2]]
[1] 4
[[1]][[3]]
[1] 9
[[2]]
[[2]][[1]]
[1] 16
[[2]][[2]]
[1] 25
[[2]][[3]]
[1] 36
Conclusion
In this article, I have explained that the lapply() function is essential in R for functional programming. It provides a versatile and efficient way to perform iterative operations on various data structures. Its ability to simplify code and handle complex transformations makes it a valuable tool for data manipulation and analysis.
Happy learning!!