R cheat sheet

R is a language built for statistics and working with data. Numbers come in vectors rather than one at a time, so a whole column is summed, filtered or plotted in a single line, and the tidyverse packages add one clear verb for each data job. The reference below is grouped by what you are trying to do, and the filter box searches all of it at once. Type dplyr to pull out the data-frame verbs, or 4.5 to see what arrived in recent releases.

Every snippet is checked against R 4.6, the current version, and was run on R 4.6.1 with dplyr 1.2.1, ggplot2 4.0.3, readr 2.2.0 and tidyr 1.3.2. Anything newer than R 4.1 says so in the notes column. Names like x, df and user are placeholders for your own, and the data examples use penguins, which ships with R from 4.5. Coming from spreadsheets or databases? The SQL cheat sheet covers the same filtering and grouping on the database side, and the Python cheat sheet is grouped the same way as this page.

A dplyr pipeline, start to finish

Read a CSV, clean it, total it per group and write the result, which is most of what day-to-day analysis looks like. This runs as it is: it writes its own sample file first.

library(readr)
library(dplyr)
 
write_lines(c(
  "date,region,product,units,price",
  "2026-09-01,north,tea,12,2.50",
  "2026-09-01,south,tea,8,2.50",
  "2026-09-02,north,coffee,5,3.20",
  "2026-09-02,south,coffee,,3.20",
  "2026-09-03,north,tea,7,2.50",
  "2026-09-03,south,cake,4,4.00"
), "sales.csv")
 
sales <- read_csv(
  "sales.csv",
  col_types = cols(
    date = col_date(), units = col_integer(), price = col_double(),
    .default = col_character()
  )
)
 
report <- sales |>
  filter(!is.na(units)) |>
  mutate(revenue = units * price) |>
  summarise(
    orders = n(),
    units = sum(units),
    revenue = sum(revenue),
    .by = c(region, product)
  ) |>
  arrange(desc(revenue))
 
report
#> # A tibble: 4 × 5
#>   region product orders units revenue
#>   <chr>  <chr>    <int> <int>   <dbl>
#> 1 north  tea          2    19    47.5
#> 2 south  tea          1     8    20
#> 3 north  coffee       1     5    16
#> 4 south  cake         1     4    16
 
write_csv(report, "report.csv")

The empty units on 2 September is read as NA, and filter(!is.na(units)) drops that row before anything is summed. Without it, sum(units) for south coffee would be NA, which spreads to every total it touches. Pinning col_types means a stray letter in the price column gives a parsing-problems warning and one NA, instead of readr quietly guessing that the whole column is text.

library(dplyr) prints a note that it masks filter, lag, intersect and a few others. That is expected: dplyr's versions now win when you call them by the plain name, and stats::filter() is still there when you need it.

Base R and dplyr, side by side

The same jobs both ways, on penguins, and every pair was run to check it gives the same result. Base R is always there with nothing to install; dplyr reads left to right and chains with the pipe.

aggregate with a formula drops rows with a missing value before it groups, which is why it needs no na.rm. The dplyr version returns groups in the order they first appear rather than sorted; add arrange(species) if the order matters.

Reshape, then plot

ggplot2 wants one row per point, so a table with a column per quarter is reshaped to long form first. This is the usual shape of a chart script.

library(tidyr)
library(ggplot2)
 
sales <- data.frame(
  region = c("north", "south", "east"),
  q1 = c(120, 95, 60),
  q2 = c(135, 90, 80),
  q3 = c(150, 110, 75)
)
 
long <- sales |>
  pivot_longer(q1:q3, names_to = "quarter", values_to = "amount")
 
print(long, n = 4)
#> # A tibble: 9 × 3
#>   region quarter amount
#>   <chr>  <chr>    <dbl>
#> 1 north  q1         120
#> 2 north  q2         135
#> 3 north  q3         150
#> 4 south  q1          95
#> # ℹ 5 more rows
 
chart <- ggplot(long, aes(quarter, amount, colour = region, group = region)) +
  geom_line(linewidth = 1) +
  geom_point(size = 2) +
  labs(title = "Sales by quarter", x = NULL, y = "Sales (£k)", colour = "Region") +
  theme_minimal()
 
ggsave("sales.png", chart, width = 6, height = 4, dpi = 150)

That saves a 900 by 600 pixel line chart with one coloured line per region. group = region is the part people leave out. quarter is text, so ggplot2 splits the data by it as well as by colour, which leaves one point per group and nothing to join: you get only points and the message Each group consists of only one observation. Passing chart to ggsave is safer than relying on the last plot, and inside a loop or a function a plot is only drawn when you print() it.

Loop, apply or vectorise

Three ways to add 20% to every price. All three give the same answer; the last is the one to write.

prices <- c(tea = 2.5, coffee = 3.2, cake = 4)
 
# A for loop, with the result created at full length first
with_vat <- numeric(length(prices))
for (i in seq_along(prices)) {
  with_vat[i] <- prices[i] * 1.2
}
names(with_vat) <- names(prices)
with_vat
#>    tea coffee   cake
#>   3.00   3.84   4.80
 
# The apply family: a function run on every element
vapply(prices, \(p) p * 1.2, numeric(1))
#>    tea coffee   cake
#>   3.00   3.84   4.80
 
# Vectorised: arithmetic already works on the whole vector
prices * 1.2
#>    tea coffee   cake
#>   3.00   3.84   4.80
 
# Where apply earns its place: a function that takes one value at a time
describe <- function(price) {
  stopifnot(is.numeric(price), length(price) == 1)
  if (price > 3) "premium" else "standard"
}
vapply(prices, describe, character(1))
#>        tea     coffee       cake
#> "standard"  "premium"  "premium"

describe uses if, which takes a single TRUE or FALSE, so it cannot be handed the whole vector: describe(prices) stops at the stopifnot line. vapply calls it once per price. For this particular job ifelse(prices > 3, "premium", "standard") is vectorised too, but most real functions are not that simple.

dplyr and SQL

The dplyr verbs map almost one to one onto SQL clauses, and the dbplyr package, installed with the tidyverse, runs them against a database by writing the SQL for you. show_query() prints what it wrote. This uses an in-memory SQLite database, so it needs nothing else installed.

library(dplyr, warn.conflicts = FALSE)
library(DBI)
 
con <- dbConnect(RSQLite::SQLite(), ":memory:")
copy_to(con, penguins, "penguins")
 
query <- tbl(con, "penguins") |>
  filter(!is.na(body_mass)) |>
  summarise(avg_mass = mean(body_mass, na.rm = TRUE), n = n(), .by = species) |>
  filter(n > 100) |>
  arrange(desc(avg_mass))
 
show_query(query)
#> <SQL>
#> SELECT `species`, AVG(`body_mass`) AS `avg_mass`, COUNT(*) AS `n`
#> FROM `penguins`
#> WHERE (NOT((`body_mass` IS NULL)))
#> GROUP BY `species`
#> HAVING (COUNT(*) > 100.0)
#> ORDER BY `avg_mass` DESC
 
collect(query)
#> # A tibble: 2 × 3
#>   species avg_mass     n
#>   <chr>      <dbl> <int>
#> 1 Gentoo     5076.   123
#> 2 Adelie     3701.   151
 
dbDisconnect(con)

A filter before summarise became WHERE, and the one after it became HAVING, which is exactly the difference the SQL cheat sheet explains. Nothing is read into R until collect(). To write SQL yourself from R, DBI takes ? placeholders, as in dbGetQuery(con, "SELECT * FROM users WHERE email = ?", params = list(email)), so user input is never pasted into the query.

Coming from Python

The differences that trip people up in their first week, with the Python cheat sheet on the other side.

Both languages round halves to the even number, so round(2.5) is 2 in each, and both give -4 for -7 floor-divided by 2.

Gotchas

The mistakes almost everyone makes in their first month of R.

sort() and order() pick an algorithm for you. For numbers, factors and logical vectors the default is a radix sort, which R's documentation says switches to an insertion sort for fewer than 200 elements and to a counting sort for integer vectors whose values span a range under 100,000. All three are on the site as step-through visualisations.

Common questions