# Looping over Objects in R Programming

Prerequisite: Data Structures in R Programming

One of the biggest issues with the “for” loop is its memory consumption and its slowness in executing a repetitive task. And when it comes to dealing with large data set and iterating over it, for loop is not advised. R provides many alternatives to be applied to vectors for looping operations that are pretty useful when working interactively on a command line. In this article, we deal with `apply()` function and its variants:

``` apply() lapply() sapply() tapply() mapply() ```

Let us see what each of these functions does.

Looping Function Operation
`apply()` Applies a function over the margins of an array or matrix
`lapply()` Apply a function over a list or a vector
`sapply()` Same as `lapply()` but with simplified results
`tapply()` Apply a function over a ragged array
`mapply()` Multivariate version of `lapply()`
• `apply()`: This function applies a given function over the margins of a given array.

apply(array, margins, function, …)

array = list of elements
margins = dimension of the array along which the function needs to be applied
function = the operation which you want to perform

Example:

 `# R program to illustrate ` `# apply() function ` ` `  `# Creating a matrix ` `A = ``matrix``(1:9, 3, 3) ` `print``(A) ` ` `  `# Applying apply() over row of matrix ` `# Here margin 1 is for row  ` `r = ``apply``(A, 1, sum) ` `print``(r) ` ` `  `# Applying apply() over column of matrix ` `# Here margin 2 is for column ` `c = ``apply``(A, 2, sum) ` `print``(c) `

Output:

```[, 1] [, 2] [, 3]
[1, ]    1    4    7
[2, ]    2    5    8
[3, ]    3    6    9

[1] 12 15 18
[1]  6 15 24
```
• `lapply():` This function is used to apply a function over a list. It always returns a list of the same length as the input list.

lapply(list, function, …)

list = Created list
function = the operation which you want to perform

Example:

 `# R program to illustrate ` `# lapply() function ` ` `  `# Creating a matrix ` `A = ``matrix``(1:9, 3, 3) ` ` `  `# Creating another matrix ` `B = ``matrix``(10:18, 3, 3)  ` ` `  `# Creating a list ` `myList = ``list``(A, B) ` ` `  `# applying lapply() ` `determinant = ``lapply``(myList, det) ` `print``(determinant) `

Output:

```[[1]]
[1] 0

[[2]]
[1] 5.329071e-15
```
• `sapply():` This function is used to simplify the result of `lapply()`, if possible. Unlike `lapply()`, the result is not always a list. The output varies in the following ways:-
• If output is a list containing elements having length 1, then a vector is returned.
• If output is a list where all the elements are vectors of same length(>1), then a matrix is returned.
• If output contains elements which cannot be simplified or elements of different types, a list is returned.

sapply(list, function, …)

list = Created list
function = the operation which you want to perform

Example:

 `# R program to illustrate ` `# sapply() function ` ` `  `# Creating a list ` `A = ``list``(a = 1:5, b = 6:10) ` ` `  `# applying sapply() ` `means = ``sapply``(A, mean) ` `print``(means) `

Output:

```a b
3 8
```

A vector is returned since the output had a list with elements of length 1.

• `tapply()`: This function is used to apply a function over subset of vectors given by a combination of factors.

tapply(vector, factor, function, …)

vector = Created vector
factor = Created factor
function = the operation which you want to perform

Example:

 `# R program to illustrate ` `# tapply() function ` ` `  `# Creating a factor ` `Id = ``c``(1, 1, 1, 1, 2, 2, 2, 3, 3) ` ` `  `# Creating a vector ` `val = ``c``(1, 2, 3, 4, 5, 6, 7, 8, 9) ` ` `  `# applying tapply() ` `result = ``tapply``(val, Id, sum) ` `print``(result) `

Output:

```1  2  3
10 18 17
```

How does the above code work?

• `mapply()`: It’s a multivariate version of `lapply()`. This function can be applied over several list simultaneously.

mapply(function, list1, list2, …)

function = the operation which you want to perform

list1, list2 = Created lists

Example:

 `# R program to illustrate ` `# mapply() function ` ` `  `# Creating a list ` `A = ``list``(``c``(1, 2, 3, 4)) ` ` `  `# Creating another list ` `B = ``list``(``c``(2, 5, 1, 6)) ` ` `  `# Applying mapply() ` `result = ``mapply``(sum, A, B) ` `print``(result) `

Output:

```[1] 24
```

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!

Previous
Next