Lecture5_Activity8

Lists

When we work with a vector, all elements must be of the same type.For lists it is possible to works with elements od different mode.

Creating lists

Technically, a list is a vector. Ordinary vectors—those of the type we’ve been using so far in this book—are termed atomic vectors, since their components cannot be broken down into smaller components. In contrast, lists are referred to as recursive vectors. List has the advantages that allows you to work with different modes in one list. In this example for each employee, we wish to store the name, salary, and a Boolean indicating union membership.

m <- list(name="Peter", salary=33000, union=T)
m

$name
[1] "Peter"

$salary
[1] 33000

$union
[1] TRUE

In order to make reference to a component of the list. Using the name of the list, dollar symbol ($) and the name of the variable you want to know.

m$name

[1] "Peter"

m$salary

[1] 33000

m$union

[1] TRUE

General List Operations

List Indexing

Above has been shown how to access to a component of a list but there more ways to do it

m$name

[1] "Peter"

m[["name"]]

[1] "Peter"

it is possible to access component name of the list using its numerical index.

m[[1]]

[1] "Peter"

lst$c • lst[[“c”]] • lst[[i]], where i is the index of c within lst

Adding and Deleting List Elements

New components can be added after a list is created

n

$a
[1] "hello"

$b
[1] 23

Selecting the place this new component is going to be and the value it is going to have.

n

$a
[1] "hello"

$b
[1] 23

$c
[1] "bye"

It is possible to add components by the vector index.

n[[4]] <- 2
n[5:7] <- c(TRUE,TRUE,FALSE)
n

$a
[1] "hello"

$b
[1] 23

$c
[1] "bye"

[[4]]
[1] 2

[[5]]
[1] TRUE

[[6]]
[1] TRUE

[[7]]
[1] FALSE

So in the fourth component position number 2 is added and from position 5 to 7 is going to be TRUE, TRUE and FALSE respectively

In order to delete a list component, value NULL is added to the component.

n$a <- NULL
n

$b
[1] 23

$c
[1] "bye"

[[3]]
[1] 2

[[4]]
[1] TRUE

[[5]]
[1] TRUE

[[6]]
[1] FALSE

As could be seen in the output component “a” has been deleted.

R allows you to concatenate lists too.

c(list("Peter", 33000, T),list(5))

[[1]]
[1] "Peter"

[[2]]
[1] 33000

[[3]]
[1] TRUE

[[4]]
[1] 5

so a list with the number 5 has been added to the initial list

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(m)

[1] 3

length(n)

[1] 6

Accessing List Components and Values

To found the names of the components, funftion names() is used.

names(m)

[1] "name"   "salary" "union" 

In this case the components with tags are name, salary and union.

In order to know the values of each of these components.

ulm

   name  salary   union 
"Peter" "33000"  "TRUE" 

The class of the unlist is character because one of the values is a character and just with one of the values being a character is enough.

class(ulm)

[1] "character"

By the way if all the values are numbers the output of class is going to be numeric

o <- list(a=13,b=56,c=3)
p <- unlist(o)
class(p)

[1] "numeric"

p

 a  b  c 
13 56  3 

However, if one of the components is a character and the rest are numbers, the class of the list is going to be Character

q <- list(a=13,b="hi",c=45)
r <- unlist(q)
class(r)

[1] "character"

r

   a    b    c 
"13" "hi" "45" 

Applying Functions to Lists

Two functions are handy for applying functions to lists: lapply and sapply.

Using the lapply() and sapply() Functions

lapply() functionn works for all values of the list and returns another list.

lapply(list(30:45,67:62,73:80),median)

[[1]]
[1] 37.5

[[2]]
[1] 64.5

[[3]]
[1] 76.5

In this case median is aplied to values between 30 to 45, 67 to 62,and 73 to 80. Then a list with the values of these medians has been created.

Sapply() function returns a vector or a matrix instead of a list.

sapply(list(30:45,67:62,73:80),median)

[1] 37.5 64.5 76.5

Extended Example: Back to the Abalone Data

Using lapply() function in an example for age.we wished to know the indices of the observations that were Old, Young, and Kid.

ag <- c("O","O","Y","Y","K","O","Y","K")
lapply(c("O","Y","K"),function(age) which(ag==age))

[[1]]
[1] 1 2 6

[[2]]
[1] 3 4 7

[[3]]
[1] 5 8

In that first case, the function calculates which(ag==“O”), giving us the vector of indices in ag of Old. After determining the indices for the Young and Kids, lapply() will return the three vectors in a list.

#####Recursive Lists Lists can be recursive, meaning that you can have lists within lists.

b <- list(k = 13, v = 99, z = 32)
c <- list(y = 45, h = 77)
a <- list(b,c)

a

[[1]]
[[1]]$k
[1] 13

[[1]]$v
[1] 99

[[1]]$z
[1] 32


[[2]]
[[2]]$y
[1] 45

[[2]]$h
[1] 77

Since a is composed of 2 lists its length is 2.

length(a)

[1] 2

This code makes a into a two-component list, with each component itself also being a list. The concatenate function c() has an optional argument recursive, which controls whether flattening occurs when recursive lists are combined

c(list(a=34,b=22,c=list(d=3,e=11)))

$a
[1] 34

$b
[1] 22

$c
$c$d
[1] 3

$c$e
[1] 11

In the above case, the default value of recursive has been accepted, which is FALSE, and obtained a recursive list, with the c component of the main list itself being another list

c(list(a=1,b=2,c=list(d=5,e=9)),recursive=T)

  a   b c.d c.e 
  1   2   5   9 

Now, writing recursive = TRUE, we got a single list as a result.