Types of data

R has different types of data, and an object’s type affects how it interacts with functions and other objects.

So far, we’ve just been working with numeric data, but there are several other types to be aware of...

Types of data

You can use typeof() to find out the type of a value or object

typeof(1)

## [1] "double"

typeof(TRUE)

## [1] "logical"

typeof(1L)

## [1] "integer"

typeof("one")

## [1] "character"

Types of data

There are a few special values worth knowing about too

Vectors

Often, we’re not working with individual values, but with a group of multiple related values -- or a vector of values.

We can create a vector of ordered numbers using the form
starting_number : ending_number.

For example, we could make x a vector with the numbers between 1 and 5.

x <- 1:5
x

## [1] 1 2 3 4 5

Let's look at the Environment pane in RStudio...

Since x is a vector, it tells us what type of vector it is and its length in addition to its contents (which can be abbreviated if the object is larger).

Vectors

We can create a vector of any numbers we want using c(), which is a function. You can think of c() as short for "combine".

You use c() by putting numbers separated by a comma within the parentheses.

# combine values into a vector and assign to an object names 'x'
x <- c(2, 8.5, 1, 9)
# print x
x

## [1] 2.0 8.5 1.0 9.0

We can also create a vector of numbers using seq().

seq() is a function that creates a sequence of numbers.

Vectors

To learn how any R function works, you can access the help documentation by typing ?function_name.

Let's take a look at how seq() works...

?seq

Vectors

What happens if we run seq() with no arguments?

seq()

## [1] 1

The seq() function has arguments with default values.

The first two arguments are from and to, which specify the starting and end values of the sequence. By default from = 1 and to = 1.

This means that typing seq() is equivalent to typing seq(from = 1, to = 1), which generates a sequence with just one value: 1.

We will talk more about how functions work in the next slide deck.

Vectors

To make a sequence from 1 to 5 with this function, we have to set the arguments accordingly: from = 1 and to = 5

seq(from = 1, to = 5)

## [1] 1 2 3 4 5

We can also set one or more of the other arguments...

The by argument allows us to change the increment of the sequence. For example, to get every other number between 1 and 5, we would set by = 2

seq(from = 1, to = 5, by = 2)

## [1] 1 3 5

Vectors

Vectors are just 1-dimensional sequences of a single type of data.

Note that vectors can also include strings or character values.

letters <- c("a", "b", "c", "d")
letters

## [1] "a" "b" "c" "d"

The general rule R uses is to set the vector to be the most "permissive" type necessary.

For example, what happens if we combine the vectors x (from earlier) and letters together?

mixed_vec <- c(x, letters)
mixed_vec

## [1] "2"   "8.5" "1"   "9"   "a"   "b"   "c"   "d"

Vectors

mixed_vec

## [1] "2"   "8.5" "1"   "9"   "a"   "b"   "c"   "d"

Notice the quotes? R turned all of our numbers into strings, since strings are more "permissive" than numbers.

typeof(mixed_vec)

## [1] "character"

This is called coercion. R coerces a vector into whichever type will accommodate all of the values. We can coerce mixed_vec to be numeric using as.numeric(), but notice what happens to the character values 👀

as.numeric(mixed_vec)

## Warning: NAs introduced by coercion

## [1] 2.0 8.5 1.0 9.0  NA  NA  NA  NA

Indexing vectors

How do we extract elements out of vectors?

This is called indexing, and it is frequently quite useful

There are a number of methods for indexing that are good to be familiar with

Indexing vectors

Indexing by position

Vectors can be indexed numerically, starting with 1 (not 0). We can extract specific elements from a vector by putting the index of their position inside brackets [].

Let's take a new vector z as an example:

z <- 6:10

z[1]

## [1] 6

z[c(1, 3)]

## [1] 6 8

Indexing Vectors

Negative indexing

z

## [1]  6  7  8  9 10

We could also say which elements not to give us using the minus sign (-).

z[-1]

## [1]  7  8  9 10

z[-c(1, 3)]

## [1]  7  9 10

Indexing Vectors

Indexing by name

Finally, if the elements in the vector have names, we can refer to them by name instead of their numerical index. You can see the names of a vector using names().

names(z)

## NULL

Looks like the elements in z have no names. We can change that by assigning them names using a vector of character values.

names(z) <- c("first", "second", "third", "fourth", "fifth")
z

##  first second  third fourth  fifth 
##      6      7      8      9     10

Indexing Vectors

Indexing by name

z

##  first second  third fourth  fifth 
##      6      7      8      9     10

Now we can use the names of the elements in z for subsetting, using quotes

z["first"]

## first 
##     6

Modifying Vectors

You can use indexing to change elements within a vector.

For example, we could change the first element of z to missing, or NA.

z[1] <- NA
z

##  first second  third fourth  fifth 
##     NA      7      8      9     10

Lists

Vectors are great for storing a single type of data, but what if we have a variety of different kinds of data we want to store together?

For example, let's say I have some information about Jane Doe that I want to store together in a single object:

• her name ("Jane Doe") -- a string
• her height in feet (5.5) -- a number
• whether or not she is right-handed (TRUE) -- a logical

A vector won't work -- every element is coerced to a character (notice the quotes).

c("Jane Doe", 5.5, TRUE)

## [1] "Jane Doe" "5.5"      "TRUE"

Instead, we can put them in a list. Lists are very flexible -- they can contain different types of data and preserve those types.

Creating Lists

We can create a list with the list() function

jane_doe <- list("Jane Doe", 5.5, TRUE)
jane_doe

## [[1]]
## [1] "Jane Doe"
## 
## [[2]]
## [1] 5.5
## 
## [[3]]
## [1] TRUE

Creating Lists

And, we can give each element of the list a name to make it easier to keep track of them.

jane_doe <- list(name = "Jane Doe",
                height = 5.5,
                right_handed = TRUE)
jane_doe

## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE

Notice that [[1]], [[2]], and [[3]], the element indices, have been replaced by the names name, height and right_handed 👀

Creating Lists

You can also see the names of a list by running names() on it

names(jane_doe)

## [1] "name"         "height"       "right_handed"

Lists are even more flexible than we've seen so far. In addition to being of heterogeneous type, each element of a list can be of different lengths.

Creating Lists

Let's add another element to the list about Jane that contains her favorite types of ice cream (she can't choose just one!)

Notice use of c() to create the element ice_cream 👀

jane_doe <- list(name = "Jane Doe",
                height = 5.5,
                right_handed = TRUE,
                ice_cream = c("mint chip", "pistachio"))
jane_doe

## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE
## 
## $ice_cream
## [1] "mint chip" "pistachio"

Indexing Lists

Indexing by position

Like vectors, lists can be indexed by their name or their position (numerically).

jane_doe[2]

## $height
## [1] 5.5

jane_doe[2] * 12

## Error in jane_doe[2] * 12: non-numeric argument to binary operator

jane_doe[[2]]

## [1] 5.5

jane_doe[[2]] * 12

## [1] 66

Indexing Lists

Indexing by name

jane_doe["height"]

## $height
## [1] 5.5

jane_doe[["height"]]

## [1] 5.5

jane_doe$height

## [1] 5.5

Modifying Lists

Just like vectors, we can change or add elements to our list using indexing.

Let's save the inches transformation of the height element as height_in.

jane_doe$height_in <- jane_doe$height * 12
jane_doe

## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE
## 
## $ice_cream
## [1] "mint chip" "pistachio"
## 
## $height_in
## [1] 66

Indexing Lists

Indexing objects within lists

As we saw with the object ice_cream stored in the list jane_doe, objects within lists can have different dimensions and length.

What if we wanted just one element of an object in a list, such as just the second element of ice_cream?

We can use indexing on the ice_cream vector stored within the jane_doe list by chaining indexes.

jane_doe[[4]][2]

## [1] "pistachio"

jane_doe[["ice_cream"]][2]

## [1] "pistachio"

jane_doe$ice_cream[2]

## [1] "pistachio"

Data frames

A data frame is a common way of representing rectangular data -- collections of values that are each associated with a variable (column) and an observation (row). In other words, it has 2 dimensions.

A data frame is technically a special kind of list -- it can contain different kinds of data in different columns, but each column must be the same length.

We can create a data frame very similarly to how we made a list, but replacing list() with data.frame().

df_1 <- data.frame(c1 = c(1, 3),
                   c2 = c(2, 4), 
                   c3 = c("a", "b"))
df_1

##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b

Indexing data frames

df_1

##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b

Indexing data frames is similar to how we index vectors, except we have two dimensions, which we use like so: [row, column]

df_1[1, 3]

## [1] "a"

df_1[, 2]

## [1] 2 4

df_1[, "c2"]

## [1] 2 4

Indexing data frames

df_1

##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b

As with lists, we can use the $ operator in the form dataframe$column_name (similar to list$object).

df_1$c1

## [1] 1 3

df_1$c1[1] # get the first value in column 1

## [1] 1

Modifying data frames

df_1

##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b

Just like lists and vectors, you can modify a data frame and add new elements or change existing elements by referencing indexes.

df_1$c4 <- df_1$c1 + df_1$c2
df_1

##   c1 c2 c3 c4
## 1  1  2  a  3
## 2  3  4  b  7

df_1$c1 <-  df_1$c1^2
df_1

##   c1 c2 c3 c4
## 1  1  2  a  3
## 2  9  4  b  7

Inspecting data frames

df_1

##   c1 c2 c3 c4
## 1  1  2  a  3
## 2  9  4  b  7

We can use the str() function to get the structure of the data. This tells us the type of each column.

str(df_1)

## 'data.frame':    2 obs. of  4 variables:
##  $ c1: num  1 9
##  $ c2: num  2 4
##  $ c3: chr  "a" "b"
##  $ c4: num  3 7

Recap

We just learned about different types of data (numeric, character, logical, factor, etc.) and some different ways they can be structured -- including vectors, lists and data frames.

Here's a quick table that summarizes data structures.

* We didn't talk about matrices today, but if you take PSY611, you will learn more about them in the context of the General Linear Model

Concept map

Source: rstudio/concept-maps