knitr::opts_chunk$set(collapse = T, comment = "#>") options(tibble.print_min = 4, tibble.print_max = 4)
This vignette compares dplyr functions to their base R equivalents. This helps those familiar with base R understand better what dplyr does, and shows dplyr users how you might express the same ideas in base R code. We'll start with a rough overview of the major differences, then discuss the one table verbs in more detail, followed by the two table verbs.
The code dplyr verbs input and output data frames. This contrasts with base R functions which more frequently work with individual vectors.
dplyr relies heavily on "non-standard evaluation" so that you don't need to
use $
to refer to columns in the "current" data frame. This behaviour
is inspired by the base functions subset()
and transform()
.
dplyr solutions tend to use a variety of single purpose verbs, while base
R solutions typically tend to use [
in a variety of ways, depending on the
task at hand.
Multiple dplyr verbs are often strung together into a pipeline by %>%
.
In base R, you'll typically save intermediate results to a variable that
you either discard, or repeatedly overwrite.
All dplyr verbs handle "grouped" data frames so that the code to perform a computation per-group looks very similar to code that works on a whole data frame. In base R, per-group operations tend to have varied forms.
The following table shows a condensed translation between dplyr verbs and their base R equivalents. The following sections describe each operation in more detail. You'll learn more about the dplyr verbs in their documentation and in vignette("dplyr")
.
| dplyr | base |
|------------------------------- |--------------------------------------------------|
| arrange(df, x)
| df[order(x), , drop = FALSE]
|
| distinct(df, x)
| df[!duplicated(x), , drop = FALSE]
, unique()
|
| filter(df, x)
| df[which(x), , drop = FALSE]
, subset()
|
| mutate(df, z = x + y)
| df$z <- df$x + df$y
, transform()
|
| pull(df, 1)
| df[[1]]
|
| pull(df, x)
| df$x
|
| rename(df, y = x)
| names(df)[names(df) == "x"] <- "y"
|
| relocate(df, y)
| df[union("y", names(df))]
|
| select(df, x, y)
| df[c("x", "y")]
, subset()
|
| select(df, starts_with("x"))
| df[grepl("^x", names(df))]
|
| summarise(df, mean(x))
| mean(df$x)
, tapply()
, aggregate()
, by()
|
| slice(df, c(1, 2, 5))
| df[c(1, 2, 5), , drop = FALSE]
|
To begin, we'll load dplyr and convert mtcars
and iris
to tibbles so that we can easily show only abbreviated output for each operation.
library(dplyr) mtcars <- as_tibble(mtcars) iris <- as_tibble(iris)
arrange()
: Arrange rows by variablesdplyr::arrange()
orders the rows of a data frame by the values of one or more columns:
mtcars %>% arrange(cyl, disp)
The desc()
helper allows you to order selected variables in descending order:
mtcars %>% arrange(desc(cyl), desc(disp))
We can replicate in base R by using [
with order()
:
mtcars[order(mtcars$cyl, mtcars$disp), , drop = FALSE]
Note the use of drop = FALSE
. If you forget this, and the input is a data frame with a single column, the output will be a vector, not a data frame. This is a source of subtle bugs.
Base R does not provide a convenient and general way to sort individual variables in descending order, so you have two options:
-x
.order()
to sort all variables in descending order.mtcars[order(mtcars$cyl, mtcars$disp, decreasing = TRUE), , drop = FALSE] mtcars[order(-mtcars$cyl, -mtcars$disp), , drop = FALSE]
distinct()
: Select distinct/unique rowsdplyr::distinct()
selects unique rows:
df <- tibble( x = sample(10, 100, rep = TRUE), y = sample(10, 100, rep = TRUE) ) df %>% distinct(x) # selected columns df %>% distinct(x, .keep_all = TRUE) # whole data frame
There are two equivalents in base R, depending on whether you want the whole data frame, or just selected variables:
unique(df["x"]) # selected columns df[!duplicated(df$x), , drop = FALSE] # whole data frame
filter()
: Return rows with matching conditionsdplyr::filter()
selects rows where an expression is TRUE
:
starwars %>% filter(species == "Human") starwars %>% filter(mass > 1000) starwars %>% filter(hair_color == "none" & eye_color == "black")
The closest base equivalent (and the inspiration for filter()
) is subset()
:
subset(starwars, species == "Human") subset(starwars, mass > 1000) subset(starwars, hair_color == "none" & eye_color == "black")
You can also use [
but this also requires the use of which()
to remove NA
s:
starwars[which(starwars$species == "Human"), , drop = FALSE] starwars[which(starwars$mass > 1000), , drop = FALSE] starwars[which(starwars$hair_color == "none" & starwars$eye_color == "black"), , drop = FALSE]
mutate()
: Create or transform variablesdplyr::mutate()
creates new variables from existing variables:
df %>% mutate(z = x + y, z2 = z ^ 2)
The closest base equivalent is transform()
, but note that it cannot use freshly created variables:
head(transform(df, z = x + y, z2 = (x + y) ^ 2))
Alternatively, you can use $<-
:
mtcars$cyl2 <- mtcars$cyl * 2 mtcars$cyl4 <- mtcars$cyl2 * 2
When applied to a grouped data frame, dplyr::mutate()
computes new variable once per group:
gf <- tibble(g = c(1, 1, 2, 2), x = c(0.5, 1.5, 2.5, 3.5)) gf %>% group_by(g) %>% mutate(x_mean = mean(x), x_rank = rank(x))
To replicate this in base R, you can use ave()
:
transform(gf, x_mean = ave(x, g, FUN = mean), x_rank = ave(x, g, FUN = rank) )
pull()
: Pull out a single variabledplyr::pull()
extracts a variable either by name or position:
mtcars %>% pull(1) mtcars %>% pull(cyl)
This equivalent to [[
for positions and $
for names:
mtcars[[1]]
mtcars$cyl
relocate()
: Change column orderdplyr::relocate()
makes it easy to move a set of columns to a new position (by default, the front):
# to front mtcars %>% relocate(gear, carb) # to back mtcars %>% relocate(mpg, cyl, .after = last_col())
We can replicate this in base R with a little set manipulation:
mtcars[union(c("gear", "carb"), names(mtcars))] to_back <- c("mpg", "cyl") mtcars[c(setdiff(names(mtcars), to_back), to_back)]
Moving columns to somewhere in the middle requires a little more set twiddling.
rename()
: Rename variables by namedplyr::rename()
allows you to rename variables by name or position:
iris %>% rename(sepal_length = Sepal.Length, sepal_width = 2)
Renaming variables by position is straight forward in base R:
iris2 <- iris names(iris2)[2] <- "sepal_width"
Renaming variables by name requires a bit more work:
names(iris2)[names(iris2) == "Sepal.Length"] <- "sepal_length"
rename_with()
: Rename variables with a functiondplyr::rename_with()
transform column names with a function:
iris %>% rename_with(toupper)
A similar effect can be achieved with setNames()
in base R:
setNames(iris, toupper(names(iris)))
select()
: Select variables by namedplyr::select()
subsets columns by position, name, function of name, or other property:
iris %>% select(1:3) iris %>% select(Species, Sepal.Length) iris %>% select(starts_with("Petal")) iris %>% select(where(is.factor))
Subsetting variables by position is straightforward in base R:
iris[1:3] # single argument selects columns; never drops iris[1:3, , drop = FALSE]
You have two options to subset by name:
iris[c("Species", "Sepal.Length")] subset(iris, select = c(Species, Sepal.Length))
Subsetting by function of name requires a bit of work with grep()
:
iris[grep("^Petal", names(iris))]
And you can use Filter()
to subset by type:
Filter(is.factor, iris)
summarise()
: Reduce multiple values down to a single valuedplyr::summarise()
computes one or more summaries for each group:
mtcars %>% group_by(cyl) %>% summarise(mean = mean(disp), n = n())
I think the closest base R equivalent uses by()
. Unfortunately by()
returns a list of data frames, but you can combine them back together again with do.call()
and rbind()
:
mtcars_by <- by(mtcars, mtcars$cyl, function(df) { with(df, data.frame(cyl = cyl[[1]], mean = mean(disp), n = nrow(df))) }) do.call(rbind, mtcars_by)
aggregate()
comes very close to providing an elegant answer:
agg <- aggregate(disp ~ cyl, mtcars, function(x) c(mean = mean(x), n = length(x))) agg
But unfortunately while it looks like there are disp.mean
and disp.n
columns, it's actually a single matrix column:
str(agg)
You can see a variety of other options at https://gist.github.com/hadley/c430501804349d382ce90754936ab8ec.
slice()
: Choose rows by positionslice()
selects rows with their location:
slice(mtcars, 25:n())
This is straightforward to replicate with [
:
mtcars[25:nrow(mtcars), , drop = FALSE]
When we want to merge two data frames, x
and y
), we have a variety of different ways to bring them together. Various base R merge()
calls are replaced by a variety of dplyr join()
functions.
| dplyr | base |
|------------------------|-----------------------------------------|
| inner_join(df1, df2)
|merge(df1, df2)
|
| left_join(df1, df2)
|merge(df1, df2, all.x = TRUE)
|
| right_join(df1, df2)
|merge(df1, df2, all.y = TRUE)
|
| full_join(df1, df2)
|merge(df1, df2, all = TRUE)
|
| semi_join(df1, df2)
|df1[df1$x %in% df2$x, , drop = FALSE]
|
| anti_join(df1, df2)
|df1[!df1$x %in% df2$x, , drop = FALSE]
|
For more information about two-table verbs, see vignette("two-table")
.
dplyr's inner_join()
, left_join()
, right_join()
, and full_join()
add new columns from y
to x
, matching rows based on a set of "keys", and differ only in how missing matches are handled. They are equivalent to calls to merge()
with various settings of the all
, all.x
, and all.y
arguments. The main difference is the order of the rows:
x
data frame.merge()
sorts the key columns.dplyr's semi_join()
and anti_join()
affect only the rows, not the columns:
band_members %>% semi_join(band_instruments) band_members %>% anti_join(band_instruments)
They can be replicated in base R with [
and %in%
:
band_members[band_members$name %in% band_instruments$name, , drop = FALSE] band_members[!band_members$name %in% band_instruments$name, , drop = FALSE]
Semi and anti joins with multiple key variables are considerably more challenging to implement.
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.