Now that we’ve covered classes, it’s time to get into the weeds a bit on how to actually access the data that gets stored in different objects with different classes.
For now, we’re going to use “Base R” syntax for this. Very soon, we’ll cover using dplyr when working with data frames, which does similar things in an (arguably) easier to understand syntax.
Ultimately, you will wind up using both, so we’ll start with the basics.
Most R objects can have their individual elements accessed via their numeric position (or “index”), which use a square brackets ([ ]) notation.
Let’s start by looking at a simple vector of all of the lowercase letters and how different elements in the vector can be accessed with bracket notation:
# Create a vector that contains the letters `a` through `z`.
a_vector <- letters
# Retrieve the first letter in the vector.
a_vector[1]## [1] "a"# Retrieve the fifth letter in the vector.
a_vector[5]## [1] "e"# Retrieve the first THROUGH fifth letters using a `:` inside the brackets.
a_vector[1:5]## [1] "a" "b" "c" "d" "e"# Retrieve the first AND fifth letters by putting a vector inside the brackets.
a_vector[c(1,5)]## [1] "a" "e"With a vector, there is only one dimension, so we only need one value inside the brackets. In a data frame, though, we have both rows and columns. So, we need to specify both dimensions, which we do by extending the [ ] notation to include a comma: [ , ].
, indicates the row(s), indicates the column(s)Note: This is sort of like R1C1 notation in Excel…except with a comma!
Let’s explore this notation a bit with a small little data frame of web data that we’ve called web_data (this is a very small data set, but this page is long enough without us including a more meaningful number of rows):
| date | channelGrouping | deviceCategory | sessions |
|---|---|---|---|
| 2016-01-01 | (Other) | desktop | 19 |
| 2016-01-01 | (Other) | mobile | 112 |
| 2016-01-01 | (Other) | tablet | 24 |
| 2016-01-01 | Direct | desktop | 133 |
| 2016-01-01 | Direct | mobile | 345 |
| 2016-01-01 | Direct | tablet | 126 |
| 2016-01-01 | Display | desktop | 307 |
| 2016-01-01 | Display | mobile | 3266 |
We can access various subsets of the data frame using [ ] notation:
# Retrieve the entire second row. Note how we include the comma, but
# we just leave the row index blank to do this.
web_data[2,]## date channelGrouping deviceCategory sessions
## 2 2016-01-01 (Other) mobile 112# Retrieve the entire fourth column. Similarly, we include the comma,
# but leave the column index blank.
web_data[,4]## [1] 19 112 24 133 345 126 307 3266Note: While the two examples above were similarly structured, notice how the output differs. When we retrieved an entire row, the result was a data frame (with a single row). When we retrieved an entire column, since, by definition, all of the values were of the same class, R went ahead and simplified the result to be a vector.
# Retrieve the second row, first column
web_data[2, 1]## [1] "2016-01-01"# Retrieve the second through fourth rows, and the first and fourth colums
web_data[2:4, c(1,4)]## date sessions
## 2 2016-01-01 112
## 3 2016-01-01 24
## 4 2016-01-01 133Subsetting by numbers assumes the rows and columns are always going to be in the same order, which can be dangerous. It’s much safer to work with names, if the names are knowable:
# Retrieve the first 5 rows of the "sessions" column
web_data[1:5, "sessions"]## [1] 19 112 24 133 345You can aso specify multiple columns by passing in a vector of column names:
web_data[1:5, c("channelGrouping","sessions")]## channelGrouping sessions
## 1 (Other) 19
## 2 (Other) 112
## 3 (Other) 24
## 4 Direct 133
## 5 Direct 345You can even reorder or repeat columns (but it will rename them to avoid clashes, which occurs behind the scenes using the make.names() function).
web_data[1:5, c("channelGrouping","deviceCategory", "sessions", "sessions")]## channelGrouping deviceCategory sessions sessions.1
## 1 (Other) desktop 19 19
## 2 (Other) mobile 112 112
## 3 (Other) tablet 24 24
## 4 Direct desktop 133 133
## 5 Direct mobile 345 345When you subset lists (including data frames) with [ ] it will, generally, return a list or data frame. If, instead, you want to return the column vector, then use [[ ]] which returns what’s actually in the list (or data frame) column.
This is confusing topic. It’s right up there with StringsAsFactors = FALSE. This is where the console comes in handy when you’re trying to make sure you have your syntax correct.
There’s a bit more going on with this notation – [ ] refers to the location of the data and [[ ]] refers to the values at the location… but let’s not get into that just yet. It’s much easier to work through this when we have a real example.
$ OperatorNow that we’re all squared away with [ ] notation, let’s look at a completely different mechanism that, as it happens, can be partnered up with [ ]s (or not): the $. The $ gets used with data frames to specify columns (based on their name) and in lists to specify elements (by their name).
# Retrieve the `sessions` column
web_data$sessions## [1] 19 112 24 133 345 126 307 3266The $ is actually just a shortcut to subsetting via a character name:
web_data[["sessions"]]## [1] 19 112 24 133 345 126 307 3266You can apply [ ] subsetting to the result of $ notation:
# The first 5 elements of the `sessions` column
web_data$sessions[1:5]## [1] 19 112 24 133 345There are many ways to pull subsets of data frames based on specific criteria (rather than explicitly identifying rows or columns). This is actually one of the ways that dplyr really shines over Base R. But, it’s useful to get comfortable with how Base R notation works, including what’s actually happening behind the scenes.
To use conditional logic, you actually wind up using our friends TRUE and FALSE (remember our discussion of the logical class earlier?). This can be a good way to select specific rows from a data frame.
For instance, to select all rows that are over 125 in the sessions column of web_data, we can construct a logical (class) vector:
# Create a TRUE or FALSE vector for every `session` element over 125
over_125 <- web_data$sessions > 125
# Display the result
over_125## [1] FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUENow, we can pass this logical vector (which has the same number of rows as our original data frame) into the row selector for web_data:
# All rows where `sessions` is over 125... and ALL columns
web_data[over_125,]## date channelGrouping deviceCategory sessions
## 4 2016-01-01 Direct desktop 133
## 5 2016-01-01 Direct mobile 345
## 6 2016-01-01 Direct tablet 126
## 7 2016-01-01 Display desktop 307
## 8 2016-01-01 Display mobile 3266Got it? If this seems a bit cumbersome…it sort of is. And, it turns out that you can shorten this all into a single line:
web_data[web_data$sessions > 125,]## date channelGrouping deviceCategory sessions
## 4 2016-01-01 Direct desktop 133
## 5 2016-01-01 Direct mobile 345
## 6 2016-01-01 Direct tablet 126
## 7 2016-01-01 Display desktop 307
## 8 2016-01-01 Display mobile 3266Notice how web_data is the overall data frame and is used as a conditional within the subsetting of that data frame.
If you only wanted certain columns, you can add that criteria “after the comma,” as discussed earlier
web_data[web_data$sessions > 125, c("channelGrouping","sessions")]## channelGrouping sessions
## 4 Direct 133
## 5 Direct 345
## 6 Direct 126
## 7 Display 307
## 8 Display 3266These can start to look pretty confusing, but, once you get comfortable with the basic syntax, you will see how things break down. And, it can be useful to build up the final syntax iteratively, much as was done in the example above, lest you wind up in nested conditional hell! (If you’re a heavy Excel user, this can be like building up beastly nested formulas.)
A couple of additional notes on the conditional selections (the use of > above):
==!=.The which() function is one that you may come across here and there, but, in general, we would recommend not using this, since it relies on numeric subsetting and can be difficult to debug.
If you are regular expression junkie (and what self-respecting web analyst isn’t?), you can use grepl() in your row or column selections to use regEx to identify which rows/columns to return. This is just another way to build those TRUE/FALSE vectors we just went through. We won’t go into that in detail now, but be aware that regEx and R are besties.
There is also a grep() function that actually returns the matched values, but, if you’re doing a selection, you actually want to return a logical vector (TRUEs and FALSEs) for your condition as to which rows you want to match…and that is what grepl() does.
If you have loaded dplyr() then it makes sense to use its select() for columns and filter() for rows instead…but, again, we’ll get there! (grepl() plays quite nicely with dplyr, too. Thanks for asking!)
So, now you can subset at will. But, what if you actually want to perform operations on a data frame – actually change subsets of the data (for cleanup for flagging or something else)? In many cases your data will come with elements you need to change that you need to filter down to. You can then reassign those values to what you prefer.
A few other functions are useful to know for these cases:
## Will return TRUE if a value is NA (e.g. imported incorrectly)
is.na(NA)## [1] TRUEa_vector <- c(1,2,3,NA,4)
is.na(a_vector)## [1] FALSE FALSE FALSE TRUE FALSELets take the previous web_data columns and say we want to set all the sessions values to 125 if they are over 125.
In this case we can filter to the elements we need like before, but this time also modifying the data in place using the <- assignment command:
# Set up a new object that is just a copy of `web_data`. The following
# operations could have just been done with `web_data` directly, but then
# the original data would be lost.
my_new_data <- web_data
# Subset the data just as we did above, but then assign that subset a
# specific value.
my_new_data[my_new_data$sessions > 125, "sessions"] <- 125
# Check out what the data looks like
my_new_data## date channelGrouping deviceCategory sessions
## 1 2016-01-01 (Other) desktop 19
## 2 2016-01-01 (Other) mobile 112
## 3 2016-01-01 (Other) tablet 24
## 4 2016-01-01 Direct desktop 125
## 5 2016-01-01 Direct mobile 125
## 6 2016-01-01 Direct tablet 125
## 7 2016-01-01 Display desktop 125
## 8 2016-01-01 Display mobile 125