How to Use apply(), lapply(), sapply(), and tapply() in R: A Practical Guide

Overview of the Apply Family Functions

While all members of the apply family serve the purpose of applying a function across a collection of elements, they are specialized for different data structures and desired output types. Choosing the correct function dramatically improves code performance and clarity, allowing analysts to avoid cumbersome manual iteration.

In essence, the primary difference lies in the dimensionality of the input data and the structure of the returned result:

• apply(): Designed for two-dimensional objects like a matrix or a data frame, allowing calculation across specific dimensions (rows or columns).
• lapply(): The standard tool for processing elements of a list structures, always guaranteeing a list as the final output.
• sapply(): A simplified version of lapply(). It attempts to simplify the output, typically returning a vector or array instead of a list when possible.
• tapply(): Specialized for summarizing data. It applies a function to subsets of a vector, where these subsets are defined by a grouping factor.

The apply() Function: Operating on Margins

The apply() function is utilized when you need to perform an operation across the rows or columns—known as margins—of an array, matrix, or data frame. It is most effective when dealing with two-dimensional numeric data, where aggregation or transformation needs to happen dimensionally rather than element-by-element.

The core strength of apply() is its explicit control over the dimension of application. By using the MARGIN argument, the user dictates whether the function should be executed independently on each row (MARGIN = 1) or each column (MARGIN = 2). This makes it indispensable for quick calculations like finding row sums, column means, or standard deviations across a dataset.

The basic syntax for the apply() function is as follows, requiring the input array (X), the dimension (MARGIN), and the function (FUN) to be applied:

apply(X, MARGIN, FUN)

• X is the name of the matrix or data frame on which the operation will be performed.
• MARGIN indicates which dimension to perform an operation across (1 for row operations, 2 for column operations).
• FUN is the specific operation you want to execute (e.g., min, max, sum, mean, or a custom anonymous function).

The following code demonstrates several practical examples of apply(), showcasing how effortlessly it can handle common statistical tasks across both rows and columns of a generated dataset.

#create a data frame with three columns and five rows
data <- data.frame(a = c(1, 3, 7, 12, 9),
                   b = c(4, 4, 6, 7, 8),
                   c = c(14, 15, 11, 10, 6))
data

#   a b  c
#1  1 4 14
#2  3 4 15
#3  7 6 11
#4 12 7 10
#5  9 8  6

#find the sum of each row
apply(data, 1, sum)

#[1] 19 22 24 29 23

#find the sum of each column
apply(data, 2, sum)

# a  b  c 
#32 29 56 

#find the mean of each row
apply(data, 1, mean)

#[1] 6.333333 7.333333 8.000000 9.666667 7.666667

#find the mean of each column, rounded to one decimal place
round(apply(data, 2, mean), 1)

#  a    b     c 
#6.4  5.8  11.2 

#find the standard deviation of each row
apply(data, 1, sd)

#[1] 6.806859 6.658328 2.645751 2.516611 1.527525

#find the standard deviation of each column
apply(data, 2, sd)

#       a        b        c 
#4.449719 1.788854 3.563706 

The lapply() Function: Always Returning a List

The lapply() function is fundamental for functional programming in R, particularly when dealing with list structures. The ‘l’ in lapply() stands for “list,” signifying that it will iterate over every element of the input object (be it a list, vector, or data frame) and return the results strictly as a list.

This guaranteed list output makes lapply() predictable and reliable, especially when the applied function (FUN) might return results of varying length or complexity for different elements. When lapply() is applied to a data frame, it treats each column as a separate element of a list and applies the function independently to each column vector.

The basic syntax for the lapply() function is simpler than apply(), as it does not require a margin argument:

lapply(X, FUN)

• X is the input object, typically a list, vector, or data frame.
• FUN is the specific operation you wish to perform on each component of X.

The following examples showcase lapply() calculating descriptive statistics on a data frame, ensuring the results—even simple scalars—are encapsulated within a list structure.

#create a data frame with three columns and five rows
data <- data.frame(a = c(1, 3, 7, 12, 9),
                   b = c(4, 4, 6, 7, 8),
                   c = c(14, 15, 11, 10, 6))
data

#   a b  c
#1  1 4 14
#2  3 4 15
#3  7 6 11
#4 12 7 10
#5  9 8  6

#find mean of each column and return results as a list
lapply(data, mean)

# $a
# [1] 6.4
#
# $b
# [1] 5.8
#
# $c
# [1] 11.2

#multiply values in each column by 2 and return results as a list
lapply(data, function(data) data*2)

# $a
# [1]  2  6 14 24 18
#
# $b
# [1]  8  8 12 14 16
#
# $c
# [1] 28 30 22 20 12

Furthermore, lapply() is the native iteration tool for actual R lists, allowing complex operations on heterogeneous elements, as demonstrated below:

#create a list
x <- list(a=1, b=1:5, c=1:10) 
x

# $a
# [1] 1
#
# $b
# [1] 1 2 3 4 5
#
# $c
# [1]  1  2  3  4  5  6  7  8  9 10

#find the sum of each element in the list
lapply(x, sum)

# $a
# [1] 1
#
# $b
# [1] 15
#
# $c
# [1] 55

#find the mean of each element in the list
lapply(x, mean)

# $a
# [1] 1
#
# $b
# [1] 3
#
# $c
# [1] 5.5

#multiply values of each element by 5 and return results as a list
lapply(x, function(x) x*5)

# $a
# [1] 5
#
# $b
# [1]  5 10 15 20 25
#
# $c
# [1]  5 10 15 20 25 30 35 40 45 50

The sapply() Function: Simplifying the Output

The sapply() function shares the same core functionality as lapply()—applying a function element-wise across an input object. However, the key distinction is its attempt to simplify the output structure. The ‘s’ stands for “simplify,” meaning it tries to convert the resulting list into the simplest possible data structure, usually a vector or a matrix, if all results are of the same atomic type and length.

This simplification makes sapply() highly popular for routine data analysis tasks because the output is immediately usable for further calculations or plotting without the need for manual unlisting. If the function returns a single value for each element (like mean or sum), sapply() returns a named vector. If the function returns a vector of the same length for each element, it returns a matrix.

The basic syntax for sapply() mirrors that of lapply():

sapply(X, FUN)

• X is the name of the list, vector, or data frame being processed.
• FUN is the function applied element-wise.

Compare the following results to the lapply() examples above. Notice how sapply() collapses the list of column means into a compact named vector:

#create a data frame with three columns and five rows
data <- data.frame(a = c(1, 3, 7, 12, 9),
                   b = c(4, 4, 6, 7, 8),
                   c = c(14, 15, 11, 10, 6))
data

#   a b  c
#1  1 4 14
#2  3 4 15
#3  7 6 11
#4 12 7 10
#5  9 8  6

#find mean of each column and return results as a vector
sapply(data, mean)

#  a   b    c 
#6.4 5.8 11.2 

#multiply values in each column by 2 and return results as a matrix
sapply(data, function(data) data*2)

#      a  b  c
#[1,]  2  8 28
#[2,]  6  8 30
#[3,] 14 12 22
#[4,] 24 14 20
#[5,] 18 16 12

When performing operations on an existing list, sapply() automatically simplifies the output, provided the structure permits:

#create a list
x <- list(a=1, b=1:5, c=1:10) 
x

# $a
# [1] 1
#
# $b
# [1] 1 2 3 4 5
#
# $c
# [1]  1  2  3  4  5  6  7  8  9 10

#find the sum of each element in the list
sapply(x, sum)

# a  b  c 
# 1 15 55 

#find the mean of each element in the list
sapply(x, mean)

#  a   b   c 
#1.0 3.0 5.5

The tapply() Function: Operations by Group

The tapply() function is uniquely designed for tasks involving grouping and aggregation, often performing split-apply-combine operations in a single step. The ‘t’ stands for “table” or “tagged,” indicating that it applies a function over subsets of a vector, where those subsets are defined by one or more grouping factors.

This function is the go-to choice when you need to calculate a statistic (like the mean, sum, or maximum) for a numerical variable segregated by categories. For instance, calculating the average height for different species in a dataset. The results are typically returned in the form of an array or a vector, indexed by the unique values of the grouping factors.

Unlike apply(), which uses numerical margins, tapply() relies on explicit indexing vectors to define the grouping structure. This specific requirement distinguishes it from the other functions in the family.

The basic syntax for the tapply() function is as follows:

tapply(X, INDEX, FUN)

• X is the data vector whose elements will be partitioned and summarized.
• INDEX is a list of one or more factors defining the grouping structure.
• FUN is the specific operation applied to each subset defined by the INDEX.

The following code utilizes tapply() on the well-known R built-in dataset, iris, to compute various statistics segmented by the flower Species factor.

#view first six lines of iris dataset
head(iris)

#  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#1          5.1         3.5          1.4         0.2  setosa
#2          4.9         3.0          1.4         0.2  setosa
#3          4.7         3.2          1.3         0.2  setosa
#4          4.6         3.1          1.5         0.2  setosa
#5          5.0         3.6          1.4         0.2  setosa
#6          5.4         3.9          1.7         0.4  setosa

#find the max Sepal.Length of each of the three Species
tapply(iris$Sepal.Length, iris$Species, max)

#setosa versicolor  virginica 
#   5.8        7.0        7.9 

#find the mean Sepal.Width of each of the three Species
tapply(iris$Sepal.Width, iris$Species, mean)

# setosa versicolor virginica 
#  3.428      2.770     2.974 

#find the minimum Petal.Width of each of the three Species
tapply(iris$Petal.Width, iris$Species, min)

#  setosa versicolor virginica 
#     0.1        1.0       1.4 

Comparative Summary of R Apply Functions

Selecting the right iteration tool in R hinges entirely on the structure of your input data and the structure of the output you require. While apply() is the workhorse for matrices, lapply() and sapply() handle iterative tasks across lists and vectors, differing only in their output simplification behavior.

The specialization of tapply() makes it irreplaceable for grouped operations, where a data frame column must be partitioned based on a categorical variable. Mastering these four functions—apply(), lapply(), sapply(), and tapply()—is a cornerstone of efficient R programming, allowing for concise and high-performance data manipulation.