## Saturday, 27 January 2018

### What is List Indexing and How to Access,Add and Delete the List Elements in R Programming

General List Operations in R Programming
We perform various List Operations like List Indexing, Adding, Deleting List elements and accessing the List elements.
Consider the following example of list, based on which we perform some general operations
j <- list(name="Joe", salary=55000, unionms=T)
> j
\$name
 "Joe"
\$salary
 55000
\$unionms
 TRUE

1) List Indexing :
You can access a list components/elements in 3 different ways:
> j\$salary
 55000

> j[["salary"]]
 55000

> j[]
 55000

We can refer to list components by their numerical indices, treating the list as a vector. However, note that in this case, we use double brackets instead of single ones.
So, there are three ways to access an individual component c of a list Lst and return it in the data type of c

Lst \$cLst [["c"]]
Lst [[i]]                # here i is the index of c within Lst

An alternative to the second and third techniques listed is to use single brackets rather than double brackets:

Lst["c"]
Lst[i]                  # here i is the index of c within Lst

Both single-bracket and double-bracket indexing access list elements in vector-index way. But there is an important difference from ordinary (atomic) vector indexing.If single brackets [ ] are used, the result is another list--a sublist of the original.
For instance, continuing to the preceding example, we can have this:

> j[1:2]
\$name
 "Joe"
\$salary
 55000

> j2 <- j
> j2

\$salary
 55000

> class(j2)
 "list"
> str(j2)
List of 1
\$ salary: num 55000

Note:
The subsetting operation returned another list consisting of the first two components of the original list j. Note that the word returned makes sense here, since index brackets are functions. This is similar to other cases we’ve seen for operators that do not at first appear to be functions, such as +.
We can use double brackets [[ ]] for referencing only a single component, with the result having the type of that component.

> j[[1:2]]
Error in j[[1:2]] : subscript out of bounds

> j2a <- j[]
> j2a
 55000

> class(j2a)
 "numeric"

2) Adding and Deleting List Elements :
We can add and delete the list elements. The new components can be added after a list is created.
> z <- list(a="abc",b=12)
> z
\$a
 "abc"

\$b
 12

# adding a c component to the existing list
> z\$c <- "third"
> z
\$a
 "abc"
\$b
 12
\$c
 "
third"

We can also add components via a vector index:
> z[] <- 28
> z[5:7] <- c(FALSE,TRUE,TRUE)

> z
\$a
 "abc"
\$b
 12
\$c
 "
third"

[]
 28
[]
 FALSE
[]
 TRUE
[]
 TRUE

We can delete a list component by setting it to NULL.
> z\$b <- NULL
> z\$a
 "abc"
\$c
 "
third"
[]
 28
[]
 FALSE
[]
 TRUE
[]
 TRUE

Note:
Note that upon deleting z\$b, the indices of the elements after it moved up by 1. For instance , the above z[] became z[].

We can also concatenate lists as follows :
z<-c(list("Joe", 55000, T),list(5))

[]
 "Joe"
[]
 55000
[]
 TRUE
[]
 5

Getting the Size of a List
Since a list is a vector, you can obtain the number of components in a list via length().
> length(z)
 4

3) Accessing List Components and Values :
Consider the following list
j <- list(name="Joe", salary=55000, unionms=T)
> j
\$name
 "Joe"
\$salary
 55000
\$unionms
 TRUE

If the components in a list do have tags, as is the case with name, salary, and unionms for j , you can obtain them via names().
The return value of unlist() is a vector—in this case, a vector of character strings. Note that the element names in this vector come from the components in the original list.
> names(j)
 "name" "salary" "unionms"

To obtain the values, use unlist():

> ulj <- unlist(j)
> ulj
name salary unionms
"Joe" "55000" "TRUE"
> class(ulj)
 "character"

On the other hand, if we were to start with numbers, we would get numbers.The output of unlist() in this case was a numeric vector.
> z <- list(a=5,b=12,c=13)
> y <- unlist(z)

> class(y)
 "numeric"
> y
a b c
5 12 13

In case of Mixed mode of data, how unlist() will works is shown below example;
> w <- list(a=5,b="xyz")
> wu <- unlist(w)
> class(wu)
 "character"

> wu
a   b
"5" "xyz"

Note:
Where possible the list components are coerced to a common mode during the unlisting, and so the result often ends up as a character vector. Vectors will be coerced to the highest type of the components in the hierarchy NULL < raw < logical < integer < real < complex < character < list < expression: pair lists are treated as lists.

Removing the List element Names :
In the above example,though wu is a vector and not a list, R did give each of the elements a name. We can remove them by setting their names to NULL.
> names(wu) <- NULL
> wu
 "5" "xyz"

We can also remove the elements’ names directly with unname(), as follows:
> wun <- unname(wu)
> wun
 "5" "xyz"

4) Using the lapply() and sapply() Functions on Lists:
The function lapply() (for list apply) works like the matrix apply() function,calling the specified function on each component of a list (or vector coerced to a list) and returning another list. Here’s an example, where R applied median() to 1:3 and to 25:29, returning a list consisting of 2 and 27.
>lapply(list(1:3,25:29),median)
[]
 2

[]
 27

Note:
In some cases, such as the example here, the list returned by lapply() could be simplified to a vector or matrix. This is exactly what sapply() (for simplified [l]apply) does.
> sapply(list(1:3,25:29),median)
 2 27

Thanks, TAMATAM