Chapter 8 Subsetting Vectors
In this lesson, we’ll see how to extract elements from a vector based on some conditions that we specify.
For example, we may only be interested in the first 20 elements of a vector, or only the elements that are not NA, or only those that are positive or correspond to a specific variable of interest. By the end of this lesson, you’ll know how to handle each of these scenarios.
I’ve created for you a vector called x that contains a random ordering of 20 numbers (from a standard normal distribution) and 20 NAs. Type x now to see what it looks like.
x
## [1] NA NA -0.71076640 -0.27720961 -0.13749304 -0.90990468 0.70780041 NA
## [9] 1.11998346 NA 1.05377147 -0.36925815 NA NA -0.64875387 -0.21305281
## [17] NA NA NA 0.23954967 0.41244572 0.05095615 -0.38330994 NA
## [25] NA NA NA NA NA NA NA NA
## [33] 2.34745556 -0.16548410 -1.33540639 -0.02695800 0.86737775 NA NA -2.52670186The way you tell R that you want to select some particular elements (i.e. a ‘subset’) from a vector is by placing an ‘index vector’ in square brackets immediately following the name of the vector.
For a simple example, try x[1:10] to view the first ten elements of x.
Index vectors come in four different flavors – logical vectors, vectors of positive integers, vectors of negative integers, and vectors of character strings – each of which we’ll cover in this lesson.
Let’s start by indexing with logical vectors. One common scenario when working with real-world data is that we want to extract all elements of a vector that are not NA (i.e. missing data). Recall that is.na(x) yields a vector of logical values the same length as x, with TRUEs corresponding to NA values in x and FALSEs corresponding to non-NA values in x.
What do you think x[is.na(x)] will give you?
- A vector of all NAs
- A vector with no NAs
- A vector of TRUEs and FALSEs
- A vector of length 0
A vector of all NAs
Prove it to yourself by typing x[is.na(x)].
Recall that ! gives us the negation of a logical expression, so !is.na(x) can be read as ‘is not NA’. Therefore, if we want to create a vector called y that contains all of the non-NA values from x, we can use y <- x[!is.na(x)]. Give it a try.
Print y to the console.
y
## [1] -0.71076640 -0.27720961 -0.13749304 -0.90990468 0.70780041 1.11998346 1.05377147 -0.36925815
## [9] -0.64875387 -0.21305281 0.23954967 0.41244572 0.05095615 -0.38330994 2.34745556 -0.16548410
## [17] -1.33540639 -0.02695800 0.86737775 -2.52670186Now that we’ve isolated the non-missing values of x and put them in y, we can subset y as we please.
Recall that the expression y > 0 will give us a vector of logical values the same length as y, with TRUEs corresponding to values of y that are greater than zero and FALSEs corresponding to values of y that are less than or equal to zero. What do you think y[y > 0] will give you?
- A vector of all the positive elements of y
- A vector of all the negative elements of y
- A vector of all NAs
- A vector of length 0
- A vector of TRUEs and FALSEs
A vector of all the positive elements of y
Type y[y > 0] to see that we get all of the positive elements of y, which are also the positive elements of our original vector x.
y[y > 0]
## [1] 0.70780041 1.11998346 1.05377147 0.23954967 0.41244572 0.05095615 2.34745556 0.86737775You might wonder why we didn’t just start with x[x > 0] to isolate the positive elements of x. Try that now to see why.
x[x > 0]
## [1] NA NA 0.70780041 NA 1.11998346 NA 1.05377147 NA NA
## [10] NA NA NA 0.23954967 0.41244572 0.05095615 NA NA NA
## [19] NA NA NA NA NA NA 2.34745556 0.86737775 NA
## [28] NASince NA is not a value, but rather a placeholder for an unknown quantity, the expression NA > 0 evaluates to NA. Hence we get a bunch of NAs mixed in with our positive numbers when we do this.
Combining our knowledge of logical operators with our new knowledge of subsetting, we could do this – x[!is.na(x) & x > 0]. Try it out.
x[!is.na(x) & x > 0]
## [1] 0.70780041 1.11998346 1.05377147 0.23954967 0.41244572 0.05095615 2.34745556 0.86737775In this case, we request only values of x that are both non-missing AND greater than zero.
I’ve already shown you how to subset just the first ten values of x using x[1:10]. In this case, we’re providing a vector of positive integers inside of the square brackets, which tells R to return only the elements of x numbered 1 through 10.
Many programming languages use what’s called ‘zero-based indexing’, which means that the first element of a vector is considered element 0. R uses ‘one-based indexing’, which (you guessed it!) means the first element of a vector is considered element 1.
Can you figure out how we’d subset the 3rd, 5th, and 7th elements of x? Hint – Use the c() function to specify the element numbers as a numeric vector.
It’s important that when using integer vectors to subset our vector x, we stick with the set of indexes {1, 2, …, 40} since x only has 40 elements. What happens if we ask for the zeroth element of x (i.e. x[0])? Give it a try.
As you might expect, we get nothing useful. Unfortunately, R doesn’t prevent us from doing this. What if we ask for the 3000th element of x? Try it out.
Again, nothing useful, but R doesn’t prevent us from asking for it. This should be a cautionary tale. You should always make sure that what you are asking for is within the bounds of the vector you’re working with.
What if we’re interested in all elements of x EXCEPT the 2nd and 10th? It would be pretty tedious to construct a vector containing all numbers 1 through 40 EXCEPT 2 and 10.
Luckily, R accepts negative integer indexes. Whereas x[c(2, 10)] gives us ONLY the 2nd and 10th elements of x, x[c(-2, -10)] gives us all elements of x EXCEPT for the 2nd and 10 elements. Try x[c(-2, -10)] now to see this.
x[c(-2, -10)]
## [1] NA -0.71076640 -0.27720961 -0.13749304 -0.90990468 0.70780041 NA 1.11998346
## [9] 1.05377147 -0.36925815 NA NA -0.64875387 -0.21305281 NA NA
## [17] NA 0.23954967 0.41244572 0.05095615 -0.38330994 NA NA NA
## [25] NA NA NA NA NA NA 2.34745556 -0.16548410
## [33] -1.33540639 -0.02695800 0.86737775 NA NA -2.52670186A shorthand way of specifying multiple negative numbers is to put the negative sign out in front of the vector of positive numbers. Thus x[-c(2, 10)] gives the exact same result!
So far, we’ve covered three types of index vectors – logical, positive integer, and negative integer. The only remaining type requires us to introduce the concept of ‘named’ elements.
Create a numeric vector with three named elements using vect <- c(foo = 11, bar = 2, norf = NA).
When we print vect to the console, you’ll see that each element has a name. Try it out.
We can also get the names of vect by passing vect as an argument to the names() function. Give that a try.
Alternatively, we can create an unnamed vector vect2 with c(11, 2, NA). Do that now.
Then, we can add the names attribute to vect2 after the fact with names(vect2) <- c(“foo”, “bar”, “norf”). Go ahead.
Now, let’s check that vect and vect2 are the same by passing them as arguments to the identical() function.
Indeed, vect and vect2 are identical named vectors.
Now, back to the matter of subsetting a vector by named elements. Which of the following commands do you think would give us the second element of vect?
- vect[“bar”]
- vect[bar]
- vect[“2”]
vect[“bar”]
Now, try it out.
Likewise, we can specify a vector of names with vect[c(“foo”, “bar”)]. Try it out.
Now you know all four methods of subsetting data from vectors. Different approaches are best in different scenarios and when in doubt, try it out!
You’ve successfully completed this lesson!