A Guide to apply(), lapply(), sapply(), and tapply() in R

Welcome to this comprehensive tutorial focusing on one of the most powerful paradigms in R programming: the family of apply functions. These built-in iteration tools—specifically apply(), sapply(), lapply(), and tapply()—are essential for performing operations efficiently across various data structures without resorting to slow, explicit loops. Understanding the nuances of each function is crucial for writing clean, fast, and scalable R code. This guide will clarify the unique purpose and syntax of these functions, providing practical examples to illustrate when and how to leverage their capabilities.

The Need for Apply Functions

In statistical computing, particularly within the R environment, vectorization and function application are highly encouraged over standard iterative structures like for loops. The suite of apply() functions offers an elegant solution to iterate over elements, rows, or columns of complex data objects, dramatically improving performance and readability. Each member of this family is specialized to handle different data structures and desired output formats, allowing programmers to execute calculations—such as finding the mean, sum, or standard deviation—in a highly efficient manner.

apply()

Introduction to apply(): Applying Functions to Dimensions

The apply() function is the foundational iteration tool, designed specifically for applying a function across the dimensions of a two-dimensional object, typically a matrix or a data frame. It is the ideal choice when you need to calculate summary statistics (like row means or column sums) for structured tabular data. Unlike its siblings, apply() requires a specific argument, MARGIN, to dictate the axis of operation, providing precise control over the direction of the calculation.

Syntax and Core Arguments

To utilize apply() effectively, you must understand its three core arguments. The function executes the specified operation (FUN) either across the rows or down the columns of the input data structure (X), depending on the dimension indicated by MARGIN.

apply(X, MARGIN, FUN)

• X is the name of the input matrix or data frame upon which the operation will be performed.
• MARGIN dictates which dimension the function is applied to: 1 specifies rows (row-wise application), and 2 specifies columns (column-wise application).
• FUN is the specific operation or function you wish to execute (e.g., min, max, sum, mean, sd, or a custom anonymous function).

Practical Demonstration of apply()

The following examples demonstrate the power and flexibility of apply(). We first create a simple data frame and then use apply() to calculate various statistics across both rows and columns by manipulating the MARGIN argument. Notice how the output is returned as an atomic vector or an array, depending on the operation.

#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 (MARGIN = 1)
apply(data, 1, sum)

#[1] 19 22 24 29 23

#find the sum of each column (MARGIN = 2)
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 

lapply()

lapply(): The List-Based Iterator

The lapply() function, which stands for “list apply,” is perhaps the most fundamental iterative function for non-dimensional data structures in R. Its primary characteristic is consistency: it always returns a list, regardless of the input type (which can be a list, vector, or data frame). This function iterates over every element (if a vector/list) or every column (if a data frame) and applies the specified function, making it indispensable for operations that might yield results of varying lengths or types.

Understanding the Syntax of lapply()

Compared to apply(), the syntax for lapply() is simpler, as it does not require a dimension argument (MARGIN). It inherently processes its input element by element or column by column.

lapply(X, FUN)

• X is the name of the input object, which is commonly a list, a vector, or a data frame.
• FUN is the function to be applied to each component of X. This can be a built-in R function or a user-defined anonymous function.

lapply() Examples on Data Frames

When lapply() is used on a data frame, it treats each column as a separate element. The results for each column are collected and returned within a named list structure. This is particularly useful when the output might not be uniform across all columns, or when you specifically require a list for subsequent processing steps.

#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 using an anonymous function 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

lapply() Examples on Lists

The most natural application for lapply() is iterating over a list, where it processes each list component sequentially. This allows for complex operations on heterogeneous data types contained within the same list structure, ensuring that the output structure mirrors the input structure, but with the results of the function applied to each element.

#create a list containing elements of different lengths
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

sapply()

sapply(): Simplifying List Output

The sapply() function, or “simplifying apply,” acts as a convenient wrapper around lapply(). It performs the exact same iteration and function application as lapply(), but with an added post-processing step: it attempts to simplify the resulting list structure into the lowest possible dimension. If the results are all single atomic values, sapply() will return a named vector. If the results are all vectors of the same length, it will return a matrix. If simplification is not possible (e.g., if the results are complex or of inconsistent lengths), it defaults back to returning a list, behaving identically to lapply().

Syntax and Simplification Logic

The syntax for sapply() is identical to lapply(), emphasizing that the difference lies only in how the output is presented, not how the iteration is performed.

sapply(X, FUN)

• X is the name of the input object (list, vector, or data frame).
• FUN is the function to be applied.

sapply() Examples on Data Frames and Simplification

These examples demonstrate the simplification process. When calculating the mean of each column, sapply() recognizes that the result is a set of single numbers, hence it returns a concise named vector instead of a cumbersome list structure. When applying a function that returns multiple values (like multiplying the column by 2), it returns a matrix.

#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 (simplification)
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 (simplification)
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

sapply() on Lists

When iterating over a list, sapply() is particularly useful for quickly generating summary statistics. If we calculate the sum or mean of the list elements, the output is simplified into a concise, easy-to-read vector, avoiding the nested structure of lapply().

#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, returned as a vector
sapply(x, sum)

# a  b  c 
# 1 15 55 

#find the mean of each element in the list, returned as a vector
sapply(x, mean)

#  a   b   c 
#1.0 3.0 5.5

tapply()

tapply(): Grouping and Subsetting Data

The tapply() function, standing for “table apply,” is designed for a specific statistical task: applying a function to subsets of a vector, where those subsets are defined by the levels of one or more grouping factors (categorical variables). This function performs the common “split-apply-combine” strategy, allowing you to calculate statistics for distinct groups within your dataset efficiently. This is invaluable in scenarios where you need to analyze data conditionally, such as finding the average height per gender or the maximum sales per region.

Syntax and Grouping Arguments

Unlike the other apply functions, tapply() requires an INDEX argument, which must contain the grouping variable(s) (typically R factors) that define how the main vector should be split.

tapply(X, INDEX, FUN)

• X is the name of the object, which must be an atomic vector containing the data you wish to summarize.
• INDEX is a list of one or more factors (or variables coercible to factors) used for grouping the data in X.
• FUN is the specific operation you want to perform on each subset defined by the INDEX.

tapply() Example using the iris Dataset

A classic demonstration of tapply() involves the built-in R dataset, iris, which contains measurements for three species of irises. We use tapply() to calculate summary statistics for continuous variables (like Sepal Length) grouped by the categorical variable (Species), showcasing its utility in rapid exploratory data analysis.

#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 

Summary of the Apply Family

Mastering the apply() family is foundational to efficient programming in R. By choosing the correct function for your data structure and desired output, you can drastically reduce the need for explicit loops, leading to code that is not only faster but also cleaner and more expressive.

• apply(): Best for matrices and data frames, requiring specification of row (1) or column (2) dimension.
• lapply(): Iterates over lists, vectors, or data frames; always returns a list.
• sapply(): A wrapper around lapply() that attempts to simplify the list output into an atomic vector or matrix when possible.
• tapply(): Specialized for grouping data; applies a function to subsets of a vector defined by categorical factors.