NB: R Data Structures

Programming for Data Science

Basic R comes with several data structures:

Vector
Matrix
Array
List
Data Frame

Here are some quick defintions before going into more detail.

Vector

A vector is an ordered collection of elements where each elements contains the same data type (integers or characters or reals or whatever).

Vectors are immutable.

Vectors are indexed beginning with the number $1$.

$1$-based indexing is used throughout R.

Matrix

A matrix is just a two-dimensional vector.

It too has one data type and is immutable.

Array

An array in R is a generalization of the vector and matrix. It may have one or more dimensions.

So, an array with one dimension is almost the same as a vector.

An array with two dimensions is almost the same as a matrix.

An array with three or more dimensions is an n-dimensional array.

They are like NumPy arrays in Python.

List

A list can hold items of different types and the list size can be increased on the fly.

List contents can be accessed either by index (like mylist[[1]]) or by name (like mylist$age).

Lists are like lists in Python.

A data frame is called a table in many languages.

This is the workhorse of R.

Each column holds the same type, and the columns can have header names.

A data frame is essential a kind of a list — a list of vectors each with the same length, but of varying data types.

Summary

Structure	Dim	Data Type	Shape	Python
Vector	$1$	single	—	—
Matrix	$2$	single	uniform	—
Array	$N$	single	uniform	NumPy array
List	$1$	multiple	ragged	List, Dict
Data Frame	$2$	multiple	uniform	Pandas Data Frame

These reflect the evolution of R.

We mainly use Vectors and Data Frames.

Vectors and `c()`

Vectors may be created with the c() function (“c” stands for combine).

Here is a vector of three numeric values:

c(2, 3, 5)

And here is a vector of logical values:

c(TRUE, FALSE, TRUE, FALSE, FALSE)

TRUE
FALSE
TRUE
FALSE
FALSE

A vector can also contain character strings:

c("aa", "bb", "cc", "dd", "ee")

'aa'
'bb'
'cc'
'dd'
'ee'

Sequences

Vectors may be created from sequences using :, seq(), and rep()

Vectors can be made out of sequences which may be generated in a few ways.

s1 <- 2:5
s1

The seq() function is like Python’s range().

s2 <- seq(from=1, to=5, by=2)
s2

You can drop the argument names and write seq(1,5,2).

The rep() function will create a series of repeated values:

s3 <- rep(1, 5)
s3

`length()`

The number of members in a vector is given by the length() function.

length(c("aa", "bb", "cc", "dd", "ee"))

Combining Vectors

Vectors can be combined via the function c().

n <- c(2, 3, 5) 
s <- c("aa", "bb", "cc", "dd", "ee") 
 c(n, s)

'2'
'3'
'5'
'aa'
'bb'
'cc'
'dd'
'ee'

Value Coercion

Notice how the numeric values are being coerced into character strings when the two vectors are combined.

This is necessary so as to maintain the same primitive data type for members in the same vector.

Vector Math

Arithmetic operations of vectors are performed member-by-member, i.e., member-wise.

We called this ‘element-wise’ in the context of NumPy.

For example, suppose we have two vectors a and b.

a <- c(1, 3, 5, 7) 
b <- c(1, 2, 4, 8)

If we multiply a by 5, we would get a vector with each of its members multiplied by 5.

5 * a

And if we add a and b together, the sum would be a vector whose members are the sum of the corresponding members from a and b.

a + b

Similarly for subtraction, multiplication and division, we get new vectors via member-wise operations.

a - b

0
1
1
-1

a * b

a / b

1
1.5
1.25
0.875

The Recycling Rule

If two vectors in an operation are of unequal length, the shorter one will be recycled in order to match the longer vector.

This is similar to broadcasting in NumPy and Pandas.

For example, the following vectors u and v have different lengths, and their sum is computed by recycling values of the shorter vector u.

u <- c(10, 20, 30) 
v <- c(1, 2, 3, 4, 5, 6, 7, 8, 9) 
u + v

Vector Indexes

We retrieve values in a vector by declaring an index inside a single square bracket index [] operator.

Vector indexes are $1$-based.

s <- c("aa", "bb", "cc", "dd", "ee") 
s[3]

'cc'

Negative Indexing

Unlike Python, if the index is negative, it will remove the member whose position has the same absolute value as the negative index.

It really does mean subtraction!

For example, the following creates a vector slice with the third member removed.

s[-3]

'aa'
'bb'
'dd'
'ee'

Out-of-Range Indexes

Values for out-of-range indexes are reported as NA.

s[10]

Numeric Index Vectors

A new vector can be sliced from a given vector with a numeric vector passed to the indexing operator.

Index vectors consist of member positions of the original vector to be retrieved.

Here we see how to retrieve a vector slice containing the second and third members of a given vector s.

s <- c("aa", "bb", "cc", "dd", "ee") 
s[c(2, 3)]

'bb'
'cc'

Duplicate Indexes

The index vector allows duplicate values. Hence the following retrieves a member twice in one operation.

s[c(2, 3, 3)]

'bb'
'cc'
'cc'

Out-of-Order Indexes

The index vector can even be out-of-order. Here is a vector slice with the order of first and second members reversed.

s[c(2, 1, 3)]

'bb'
'aa'
'cc'

In Python, we called this “fancy indexing.”

Range Index

To produce a vector slice between two indexes, we can use the colon sequence operator :.

This can be convenient for situations involving large vectors.

s[2:4]

'bb'
'cc'
'dd'

Logical Index Vectors

A new vector can be sliced from a given vector with a logical index vector.

The logical vector must the same length as the original vector.

Its members are TRUE if the corresponding members in the original vector are to be included in the slice, and FALSE if otherwise.

This is what we called boolean indexing and masking in Python.

For example, consider the following vector s of length $5$.

s <- c("aa", "bb", "cc", "dd", "ee")

To retrieve the the second and fourth members of s, we define a logical vector L of the same length, and have its second and fourth members set as TRUE.

L = c(FALSE, TRUE, FALSE, TRUE, FALSE)
s[L]

'bb'
'dd'

The code can be abbreviated into a single line.

s[c(FALSE, TRUE, FALSE, TRUE, FALSE)]

'bb'
'dd'

Naming Vector Members with `names()`

We can assign names to vector members, too.

v <- c("Mary", "Sue") 
names(v) <- c("First", "Last") 
v

First: 'Mary'
Last: 'Sue'

Now we can retrieve the first member by name, much like a Python dictionary.

v["First"]

First: 'Mary'

We can also reverse the order with a character string index vector.

v[c("Last", "First")]

Last: 'Sue'
First: 'Mary'

Lists

A list is a generic vector containing other objects.

This is close to a Python list.

The following variable x is a list containing copies of three vectors n, s, b, and a numeric value $3$.

n <- c(2, 3, 5) 
s <- c("aa", "bb", "cc", "dd", "ee") 
b <- c(TRUE, FALSE, TRUE, FALSE, FALSE) 

x <- list(n, s, b, 3)   # x contains copies of n, s, b
x

1. 2
2. 3
3. 5
1. 'aa'
2. 'bb'
3. 'cc'
4. 'dd'
5. 'ee'
1. TRUE
2. FALSE
3. TRUE
4. FALSE
5. FALSE
3

We can call the print function to show how R represents these values internally.

print(x)

[[1]]
[1] 2 3 5

[[2]]
[1] "aa" "bb" "cc" "dd" "ee"

[[3]]
[1]  TRUE FALSE  TRUE FALSE FALSE

[[4]]
[1] 3

Note that odd bracket notation.

It indicates that each list member contains a vector, even if the length of the vector is $1.$

List Slicing

We retrieve a list slice with the single square bracket [] operator.

The following is a slice containing the second member of x, which is a copy of s.

x[2]

1. 'aa'
2. 'bb'
3. 'cc'
4. 'dd'
5. 'ee'

With a vector, we can retrieve a slice with multiple members.

Here a slice containing the second and fourth members of x.

x[c(2, 4)]

1. 'aa'
2. 'bb'
3. 'cc'
4. 'dd'
5. 'ee'
3

Member Reference with `[[]]`

To reference a list member directly, we use the double square bracket [[]] operator.

The following object x[[2]] is the second member of x.

In other words, *x[[2]] is a true copy of s, not a slice containing s or its copy.

print(x[2])

[[1]]
[1] "aa" "bb" "cc" "dd" "ee"

print(x[[2]])

[1] "aa" "bb" "cc" "dd" "ee"

We can modify its content directly.

x[[2]][1] <- "ta"

print(x[2])

[[1]]
[1] "ta" "bb" "cc" "dd" "ee"

And s is unaffected.

print(s)

[1] "aa" "bb" "cc" "dd" "ee"

Note that this notation is opposite to Python’s syntax in NumPy and Pandas.

In Python, a double bracket containing a single value passed to a DataFrame would return a DataFrame, whereas a single bracket would return a Series.

This is because the double bracket means a list is being used to select data, whereas a single bracket means a scalar is being used.

df[[x]] # Returns a one column DataFrame
df[x]   # Returns a Series

Factors

Finally, let’s take a quick look at categorical data.

Categorical data are called “factors” in R.

Categorical data consist of numbers or strings that form a finite set of possible values.

Examples include scales and disjoint labels:

Male, Female
True, False
1, 2, 3, 4, 5 (Likert Scale)
A, B, C, D, E, F, G (musical notes)

Although it looks like a data type, a factor is actually kind of data structure, since they organize data types, i.e. characters and numbers.

Factoris categorize data into levels.

Levels are distinct values, like sets in Python or LOVs in SQL.

Levels are stored alongside the vector in the factor object.

Levels constrain what can be added to the factor vector.

Levels are always characters, even when the data are numeric or boolean

They are created with factor() taking a vector as input.

They are analagous to categories in Pandas.

Let’s looks at an example.

Take a vector of integers.

v1 <- c(1,5,6,9,4,3,5,8,7,6,3,0,0,0,1,2,3,6,4,5,7,9)

Noticess that it has no levels associated with it.

levels(v1)

NULL

We may convert the vector in a factor, like so:

f1 = factor(v1)

Now see that it has extracted a distinct list of items and converted them to strings.

print(levels(f1))

 [1] "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"

Printing the factor shows that the object contains two structures:

print(f1)

 [1] 1 5 6 9 4 3 5 8 7 6 3 0 0 0 1 2 3 6 4 5 7 9
Levels: 0 1 2 3 4 5 6 7 8 9

The object has properties accessible by functions.

print(nlevels(f1))

[1] 10

print(levels(f1))

 [1] "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"

Note that levels act as a constraint on the factor vector.

If we want to edit the factor to have a value that is not in the distinct list of levels, we get an error.

f1[5] <- 20

Warning message in `[<-.factor`(`*tmp*`, 5, value = 20):
“invalid factor level, NA generated”

Note that we also blow away the original value!

print(f1)

 [1] 1    5    6    9    <NA> 3    5    8    7    6    3    0    0    0    1   
[16] 2    3    6    4    5    7    9   
Levels: 0 1 2 3 4 5 6 7 8 9