Select columns with select()

suppressPackageStartupMessages(library(nycflights13))

package 㤼㸱nycflights13㤼㸲 was built under R version 3.6.3

suppressPackageStartupMessages(library(tidyverse))

package 㤼㸱tidyverse㤼㸲 was built under R version 3.6.3

1. Brainstorm as many ways as possible to select dep_time, dep_delay, arr_time, and arr_delay from flights.

These are a few ways to select columns.

• Specify columns names as unquoted variable names.

select(flights, dep_time, dep_delay, arr_time, arr_delay)

• Specify column names as strings.

select(flights, "dep_time", "dep_delay", "arr_time", "arr_delay")

• Specify the column numbers of the variables.

select(flights, 4, 6, 7, 9)

This works, but is not good practice for two reasons. First, the column location of variables may change, resulting in code that may continue to run without error, but produce the wrong answer. Second code is obfuscated, since it is not clear from the code which variables are being selected. What variable does column 6 correspond to? I just wrote the code, and I’ve already forgotten.

• Specify the names of the variables with character vector and one_of().

select(flights, one_of(c("dep_time", "dep_delay", "arr_time", "arr_delay")))

This is useful because the names of the variables can be stored in a variable and passed to one_of().

variables <- c("dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, one_of(variables))

• Selecting the variables by matching the start of their names using starts_with().

select(flights, starts_with("dep_"), starts_with("arr_"))

Selecting the variables using regular expressions with matches(). Regular expressions provide a flexible way to match string patterns and are discussed later.

select(flights, matches("^(dep|arr)_(time|delay)$"))

Some things that don’t work are

• Matching the ends of their names using ends_with() since this will incorrectly include other variables. For example,

select(flights, ends_with("arr_time"), ends_with("dep_time"))

• Matching the names using contains() since there is not a pattern that can include all these variables without incorrectly including others.

select(flights, contains("_time"), contains("arr_"))

2.What happens if you include the name of a variable multiple times in a select() call?

The select() call ignores the duplication. Any duplicated variables are only included once, in the first location they appear. The select() function does not raise an error or warning or print any message if there are duplicated variables.

select(flights, year, month, day, year, year)

This behavior is useful because it means that we can use select() with everything() in order to easily change the order of columns without having to specify the names of all the columns.

select(flights, arr_delay, everything())

3. What does the one_of() function do? Why might it be helpful in conjunction with this vector?

The one_of() function selects variables with a character vector rather than unquoted variable name arguments. This function is useful because it is easier to programmatically generate character vectors with variable names than to generate unquoted variable names, which are easier to type.

vars <- c("year", "month", "day", "dep_delay", "arr_delay")
select(flights, one_of(vars))

In the most recent versions of dplyr you can provide the name of a vector containing the variable names you wish to select.

select(flights, vars)

However there is a problem with this. It is not clear whether vars refers to a column name or a variable. The way the code is evaluated will depend on whether vars is column in flights. If vars was a column in flights, then that code would select only the vars column. If vars is not a column in flights, as is the case, then select will replace it with its value, and select those columns. If it has the same name or to ensure that it will not conflict with the names of the columns in the data frame, use the !!! (bang-bang-bang) operator.

select(flights, !!!vars)

This behavior, which is used by many tidyverse functions, is an example of what is called non-standard evaluation (NSE) in R. See the dplyr vignette, Programming with dplyr, for more information on this topic.

4.Does the result of running the following code surprise you? How do the select helpers deal with case by default? How can you change that default?

select(flights, contains("TIME"))

The default behavior for contains() is to ignore case. This may or may not surprise you. If this behavior does not surprise you, that could be why it is the default. Users searching for variable names probably have a better sense of the letters in the variable than their capitalization. A second, technical, reason is that dplyr works with more than R data frames. It can also work with a variety of databases. Some of these database engines have case insensitive column names, so making functions that match variable names case insensitive by default will make the behavior of select() consistent regardless of whether the table is stored as an R data frame or in a database.

To change the behavior add the argument ignore.case = FALSE.

select(flights, contains("TIME", ignore.case = FALSE))