The Ultimate Swiss Army Knife: Mastering the ‘apply‘ Family of Functions in R

Introduction

If you‘re an aspiring data scientist or analyst working in R, sooner or later you‘ll need to wrangle and transform data in your analyses. While R provides many ways to manipulate data, one of the most powerful and efficient toolkits at your disposal is the ‘apply‘ family of functions.

Just like a Swiss Army knife, the ‘apply‘ functions are versatile, multipurpose tools that allow you to slice and dice your data in myriad ways with minimal code. Whether you need to apply mathematical operations, aggregate data, or transform variables, chances are there‘s an ‘apply‘ function perfectly suited for the job.

In this guide, we‘ll walk through each of the core ‘apply‘ functions in detail, providing examples of how and when to use them. By the end, you‘ll be equipped to wield these functions with confidence in your own data science projects. Let‘s dive in!

The Core ‘apply‘ Functions

While there are several more obscure ‘apply‘ variants, in this guide we‘ll focus on the six core functions that comprise the heart of the ‘apply‘ family:

apply()

The apply() function is used to apply a function over the margins of an array (e.g. the rows or columns of a matrix). It takes three key arguments:

• X: the array to apply the function to
• MARGIN: an integer vector indicating the dimensions to apply over (1 for rows, 2 for columns)
• FUN: the function to apply

To illustrate, let‘s create a matrix and use apply() to calculate the sum of each row:

# create 5x4 matrix 
mat <- matrix(1:20, nrow=5)

# calculate sum of each row
apply(mat, 1, sum)
#> [1] 50 55 60 65 70

We can also use apply() to apply a function to each individual element of an array by passing c(1,2) as the MARGIN argument:

# square root each element
apply(mat, c(1,2), sqrt) 
#>          [,1]    [,2]    [,3]    [,4]
#> [1,] 1.000000 1.41421 1.73205 2.00000
#> [2,] 2.23607 2.44949 2.64575 2.82843
#> [3,] 3.00000 3.16228 3.31662 3.46410
#> [4,] 3.60555 3.74166 3.87298 4.00000
#> [5,] 4.12311 4.24264 4.35890 4.47214

lapply()

The lapply() function applies a function to each element of a list or vector, returning a list of the same length as the input. Unlike apply(), it does not require the input to be an array.

# create a list
mylist <- list(A=1:5, B=6:10, C=11:15)

# multiply each element by 2
lapply(mylist, function(x) x*2)
#> $A
#> [1]  2  4  6  8 10
#> 
#> $B 
#> [1] 12 14 16 18 20
#>
#> $C
#> [1] 22 24 26 28 30

sapply()

sapply() works just like lapply(), but it attempts to simplify the output to a vector or matrix if possible. This is useful when each element of the output list has length 1.

sapply(mylist, sum)
#>  A  B  C 
#> 15 40 65

If the output can‘t be simplified, sapply() will just return a list like lapply().

vapply()

vapply() is a variant of sapply() that allows you to specify the type of output you expect. This adds a layer of type safety and can make your code more robust.

vapply(mylist, sum, numeric(1))
#>  A  B  C 
#> 15 40 65

If the type of output doesn‘t match what you specify, vapply() will throw an error. This is handy for debugging!

tapply()

tapply() applies a function to each subset of a vector based on a factor (grouping) variable. This allows you to easily aggregate or summarize your data by group.

# generate sample data 
set.seed(123)
mydf <- data.frame(
  group = rep(c("A","B","C"), each=5),
  score = rnorm(15)
)

# calculate mean score by group
tapply(mydf$score, mydf$group, mean)
#>          A          B          C 
#>  0.4087384 -0.4247031  0.4123781

mapply()

mapply() is a multivariate version of sapply() that applies a function to the first elements of each argument, then the second elements, and so on. It‘s handy for performing "parallel" operations on multiple objects.

mapply(rep, times=1:4, x=c("A","B","C","D"))
#> [[1]]
#> [1] "A"
#> 
#> [[2]]
#> [1] "B" "B"
#> 
#> [[3]]
#> [1] "C" "C" "C"
#> 
#> [[4]]
#> [1] "D" "D" "D" "D"

Putting the ‘apply‘ Functions to Work

Now that we‘ve covered the fundamentals, let‘s see the ‘apply‘ family in action on a real dataset. We‘ll use the classic iris dataset included in R.

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

Let‘s say we want to calculate the mean sepal length and width for each iris in the dataset. We can use apply() to do this concisely:

iris$sepal_mean <- apply(iris[,c("Sepal.Length", "Sepal.Width")], 1, mean)
head(iris)
#>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species sepal_mean
#> 1          5.1         3.5          1.4         0.2  setosa       4.30
#> 2          4.9         3.0          1.4         0.2  setosa       3.95
#> 3          4.7         3.2          1.3         0.2  setosa       3.95
#> 4          4.6         3.1          1.5         0.2  setosa       3.85
#> 5          5.0         3.6          1.4         0.2  setosa       4.30
#> 6          5.4         3.9          1.7         0.4  setosa       4.65

We can also use tapply() to quickly calculate summary statistics by group, such as the average petal width per iris species:

tapply(iris$Petal.Width, iris$Species, mean)
#>     setosa versicolor  virginica 
#>      0.246      1.326      2.026

Or we can use mapply() to generate a new variable based on the parallel operation of two others, like the sum of petal length and width:

iris$petal_sum <- mapply(sum, iris$Petal.Length, iris$Petal.Width) 
head(iris)
#>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species sepal_mean petal_sum
#> 1          5.1         3.5          1.4         0.2  setosa       4.30       1.6
#> 2          4.9         3.0          1.4         0.2  setosa       3.95       1.6
#> 3          4.7         3.2          1.3         0.2  setosa       3.95       1.5
#> 4          4.6         3.1          1.5         0.2  setosa       3.85       1.7
#> 5          5.0         3.6          1.4         0.2  setosa       4.30       1.6
#> 6          5.4         3.9          1.7         0.4  setosa       4.65       2.1

When to Reach for Your ‘apply‘ Toolkit

With so many ‘apply‘ functions to choose from, it can be hard to know which one to use when. Here are some rules of thumb:

• If you need to apply a function over the rows or columns of a matrix or array, use apply().
• If you‘re working with a list or vector, lapply() or sapply() are usually best. Use lapply() if you want a list output, sapply() to simplify.
• Need to ensure type safety? vapply() is your friend.
• To apply a function to subsets of a vector based on a grouping variable, tapply() is the way to go.
• If you have multiple vectors or lists that you need to operate on in parallel, mapply() has you covered.

In general, any time you find yourself using a loop to apply a function to slices of your data, pause and consider whether one of the ‘apply‘ functions could do the job more efficiently. Chances are the answer is yes!

Conclusion

The ‘apply‘ family of functions are a core part of any R user‘s toolkit, allowing you to flexibly and efficiently manipulate your data with minimal code. By understanding how to wield these versatile tools, you can supercharge your data wrangling and spend more time on the fun parts of data science, like modeling and visualization.

We‘ve only scratched the surface of what you can do with ‘apply‘ and its cousins. I encourage you to experiment with these powerful functions on your own datasets – I think you‘ll quickly appreciate how indispensable they are. Happy applying!