Lists
and Its General List Operations in R Programming
Lists
In
R programming, a list is a collection of different data types such as vectors,
matrices, and other lists. Unlike vectors and matrices, lists can contain data
of different types, and each element of a list can have a unique name. Lists
are flexible data structures that are useful for storing and manipulating
complex data.
Syntax: list(x,
y, z, ...)
Parameters:
x, y, z: the objects to be included in
the list.
...: additional objects to be included
in the list.
Ø Types of Lists:
l Named
List: a list with named elements.
l Unnamed
List: a list without named elements.
General
list operations
In
R programming, lists are a versatile data structure that can hold elements of
different data types, including vectors, matrices, other lists, and even
functions.
Here
are some general list operations in R programming:
l Creating
a list:
Lists can be created using the list()
function
Syntax: my_list
<- list(item1, item2, item3, ...)
where
item1, item2, item3 are the objects or values to be included in the list.
l Accessing
list elements:
List elements can be accessed using
double brackets [[ ]] or single brackets [ ].
Syntax: my_list[[index]]
where
my_list is the name of the list and index is the index of the element to be
accessed.
l Naming
list elements:
List elements can be named during or
after creation using the names() function.
Syntax: names(my_list)
<- c("name1", "name2", "name3", ...)
where
my_list is the name of the list and "name1", "name2",
"name3" are the names to be assigned to the elements of the list.
l Merging
two or more lists:
Lists can be merged using the c()
function or the append() function.
Syntax: merged_list
<- c(list1, list2, list3, ...)
where
list1, list2, list3 are the lists to be merged.
Example :
# Create a list of vectors
my_list <- list(vec1 = c(1, 2, 3), vec2 = c(4, 5, 6), vec3 =
c(7, 8, 9))
print(my_list) # Print
the list
my_list[[1]][1] # Access
the first element of the first vector in the list
names(my_list) <- c("First", "Second",
"Third") # Set the names of the list elements
print(my_list) # Print
the named list
# Create a second list of vectors
my_second_list <- list(vec4 = c(10, 11, 12), vec5 = c(13, 14,
15))
merged_list <- c(my_list, my_second_list) # Merge
the two lists
print(merged_list) # Print
the merged list
Output :
$vec1 ----------1
[1] 1 2 3
$vec2
[1] 4 5 6
$vec3
[1] 7 8 9
$First -----------2
[1] 1 2 3
$Second
[1] 4 5 6
$Third
[1] 7 8 9
$vec4 -----------3
[1] 10 11 12
$vec5 -----------4
[1] 13 14 15
Manipulating
list elements:
List elements
can be manipulated using various functions such as lapply(), sapply(),
mapply(), Map(), and purrr::map().
l Adding
a new element:
Elements can be
added to a list using the append() function or by assigning a new element to a
specific index.
Syntax: my_list[["new_element"]]
<- value
where "new_element" is the
name of the new element and value is the value to be assigned to it.
l Removing
an element:
Elements can be
removed from a list using the [[ ]] or [ ] operator with the - sign.
Syntax: my_list[[index]]
<- NULL
where the
index is the index of the element to be removed.
l Modifying
an element:
Syntax: my_list[[index]]
<- new_value
where
index is the index of the element to be modified and new_value is the new value
to be assigned to it.
Example :
my_list
<- list(name="John", age=30, city="New York") #
Create a list
my_list$city
<- "Chicago" #
Change the value of the 'city' element
print(my_list) #
Print the modified list
Output:
$name
[1]
"John"
$age
[1]
30
$city
[1]
"Chicago"
Converting
a list to a vector:
Syntax: unlist(my_list)
where
my_list is the name of the list.
Example :
my_list
<- list("John", 30, "New York") #
Create a list
my_vector
<- unlist(my_list) #
Convert the list to a vector
print(my_vector) #
Print the vector
Output:
[1] "John"
"30" "New York"
Recursive Function Lists In R Programming
