Andrew Gard, Ph.D

Working with factors in R

Andrew Gard — Mon, 07 Sep 2026 05:00:00 GMT

Categorical variables (or factors as they are referred to when working in R) are variables that assign observations to specific groups. This post will cover some of the most common problems you may encounter while trying to visualize or model such variables.

Throughout, I’ll refer to the scooby data set, originally sourced from kaggle but modified slightly for use in my vids and in this post. A download link can be found at the end of this tutorial.

# Load and prep data

library(tidyverse)
theme_set(theme_minimal())

library(readxl)
scooby <- read_excel("_internal/scooby.xlsx") 

scooby_sm <- scooby |> 
  filter(format == "TV Series") |>  
  select(title,  
         date_aired,
         imdb,
         motive)

Factor, character, and other vector types

As a general rule, tidyverse functions treat character vectors as factors. For instance, we can apply dplyr::count to scooby$motive, even though the latter just consists of strings.

glimpse(scooby_sm)

Rows: 374
Columns: 4
$ title       "What a Night for a Knight", "A Clue for Scooby Doo", "Hass…
$ date_aired  1969-09-13, 1969-09-20, 1969-09-27, 1969-10-04, 1969-10-11…
$ imdb        8.1, 8.1, 8.0, 7.8, 7.5, 8.4, 7.6, 8.2, 8.1, 8.0, 8.5, 8.2,…
$ motive      "Theft", "Theft", "Treasure", "Natural Resource", "Competit…

scooby_sm |> 
  count(motive)

# A tibble: 17 × 2
   motive               n
               
 1 Abduction            3
 2 Assistance           2
 3 Competition        130
 4 Conquer             33
 5 Counterfeit          6
 6 Entertainment        3
 7 Extortion            3
 8 Imagination          1
 9 Inheritance          6
10 Natural Resource    19
11 Preservation        10
12 Safety               2
13 Simulation           2
14 Smuggling           19
15 Theft               93
16 Treasure            40
17                  2

Use as.factor() to explicitly coerce variables to factors. This is particularly useful when category levels are numeric, like am (automatic/manual transmission) in the built-in mtcars set, since functions like ggplot will otherwise attempt to treat them as continuous variables. For instance, we can’t get directly get a side-by-side boxplot of mpg vs am.

glimpse(mtcars)

Rows: 32
Columns: 11
$ mpg   21.0, 21.0, 22.8, 21.4, 18.7, 18.1, 14.3, 24.4, 22.8, 19.2, 17.8,…
$ cyl   6, 6, 4, 6, 8, 6, 8, 4, 4, 6, 6, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 8,…
$ disp  160.0, 160.0, 108.0, 258.0, 360.0, 225.0, 360.0, 146.7, 140.8, 16…
$ hp    110, 110, 93, 110, 175, 105, 245, 62, 95, 123, 123, 180, 180, 180…
$ drat  3.90, 3.90, 3.85, 3.08, 3.15, 2.76, 3.21, 3.69, 3.92, 3.92, 3.92,…
$ wt    2.620, 2.875, 2.320, 3.215, 3.440, 3.460, 3.570, 3.190, 3.150, 3.…
$ qsec  16.46, 17.02, 18.61, 19.44, 17.02, 20.22, 15.84, 20.00, 22.90, 18…
$ vs    0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,…
$ am    1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0,…
$ gear  4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 4, 4, 4, 3, 3,…
$ carb  4, 4, 1, 1, 2, 1, 4, 2, 2, 4, 4, 3, 3, 3, 4, 4, 4, 1, 2, 1, 1, 2,…

ggplot(mtcars, aes(x = am, 
                   y = mpg)) + 
  geom_boxplot() # not what we want

Warning: Orientation is not uniquely specified when both the x and y aesthetics are
continuous. Picking default orientation 'x'.

Warning: Continuous x aesthetic
ℹ did you forget `aes(group = ...)`?

While it’s fine to follow the recommendation given in this warning message, it may be better to just convert am to a factor once and for all:

mtcars2 <- mtcars |> 
  mutate(am = as.factor(am)) 

ggplot(mtcars2, aes(x = am, 
                    y = mpg)) + 
  geom_boxplot()

Relabeling factors

There are many options for changing the text used to label factor levels, but fct_recode() is a solid choice.

mtcars2 <- mtcars2 |> 
  mutate(am = fct_recode(am, 
                         "automatic" = "0",
                         "manual" = "1"))
mtcars2 |> 
  count(am)

         am  n
1 automatic 19
2    manual 13

Notice the syntax, “new_name” = “old_name”, which is common in tidyverse R.

When you have a large number of different factor levels, it may be helpful to lump the less common ones into an “other” category. For instance, the next chunk combines all categories with fewer than 20 occurrences.

scooby_sm2 <- scooby_sm |> 
  mutate(motive = fct_lump_min(motive,
                               min = 20)) 
scooby_sm2 |> 
  count(motive) |> 
  arrange(-n)

# A tibble: 6 × 2
  motive          n
         
1 Competition   130
2 Theft          93
3 Other          76
4 Treasure       40
5 Conquer        33
6             2

Also check out fct_lump_n() to specify the number of levels retained, fct_lump_prop() to lump low-percentage levels, and fct_lump_lowfreq() to try to force the new “Other” level to have lowest frequency.

Rearranging levels

Sometimes the order of factor levels matters, for instance in a bar chart. The default odering is alphanumeric.

ggplot(scooby_sm2, 
       aes(x = motive)) + 
  geom_bar()

Use fct_relevel() to shift levels to the front. For instance, the next code chunk places the motives Treasure and Theft before Compitition and others.

scooby_sm3 <- scooby_sm2 |> 
  mutate(motive = fct_relevel(motive,
                              "Treasure",
                              "Theft")) 

ggplot(scooby_sm3, 
       aes(x = motive)) + 
  geom_bar()

Often, you just want to put the most common factor levels first. Use fct_infreq() to accomplish this.

ggplot(scooby_sm2, aes(x = fct_infreq(motive))) + 
  geom_bar()

You can also reverse the order of the factor levels with fct_rev.

Reordering levels using a second variable

For some plots, it can be natural to order a categorical variable using a numeric one. For instance, in the next plot, it would be preferable to show the various motives in increasing order of imdb ratings.

ggplot(scooby_sm3, aes(x = motive,
                       y = imdb)) + 
  geom_boxplot()

Use fct_reorder to accomplish this.

scooby_sm4 <- scooby_sm3 |> 
  mutate(motive = fct_reorder(motive,
                              imdb))

ggplot(scooby_sm4, aes(x = motive,
                       y = imdb)) + 
  geom_boxplot()

By default, fct_reorder sorts using the median. You can specify a different function (like mean) by adding a .fun argument.

Ordered factors

Occasionally you may encounter ordered factors, ones of class ord. For the most part, you can treat these like regular factors.

glimpse(diamonds)

Rows: 53,940
Columns: 10
$ carat    0.23, 0.21, 0.23, 0.29, 0.31, 0.24, 0.24, 0.26, 0.22, 0.23, 0.…
$ cut      Ideal, Premium, Good, Premium, Good, Very Good, Very Good, Ver…
$ color    E, E, E, I, J, J, I, H, E, H, J, J, F, J, E, E, I, J, J, J, I,…
$ clarity  SI2, SI1, VS1, VS2, SI2, VVS2, VVS1, SI1, VS2, VS1, SI1, VS1, …
$ depth    61.5, 59.8, 56.9, 62.4, 63.3, 62.8, 62.3, 61.9, 65.1, 59.4, 64…
$ table    55, 61, 65, 58, 58, 57, 57, 55, 61, 61, 55, 56, 61, 54, 62, 58…
$ price    326, 326, 327, 334, 335, 336, 336, 337, 337, 338, 339, 340, 34…
$ x        3.95, 3.89, 4.05, 4.20, 4.34, 3.94, 3.95, 4.07, 3.87, 4.00, 4.…
$ y        3.98, 3.84, 4.07, 4.23, 4.35, 3.96, 3.98, 4.11, 3.78, 4.05, 4.…
$ z        2.43, 2.31, 2.31, 2.63, 2.75, 2.48, 2.47, 2.53, 2.49, 2.39, 2.…

diamonds |> 
  count(cut) # several ordered factors

# A tibble: 5 × 2
  cut           n
       
1 Fair       1610
2 Good       4906
3 Very Good 12082
4 Premium   13791
5 Ideal     21551

Specifying that a factor is ordered (for instance using ordered) can occasionally matter in modeling applications and certain forms of statistical inference. Other than that, the most visible difference with ordered factors in R is how they’re displayed by ggplot.

ggplot(diamonds, aes(x = cut,
                     fill = cut)) + 
  geom_bar(show.legend = FALSE)

By default, ordered factors are colored using the viridis palette, which is has a distinct order to it.

Want more?

If something here isn’t clear, there’s a good chance you’ll find an explanation in my vid on the subject:

Regular expressions for R users

Andrew Gard — Mon, 24 Aug 2026 05:00:00 GMT

Searching and manipulating strings (those things that make up character vectors) is easy as long as you only need to match specific sequences of letters and numbers. To match patterns rather than specific substrings or to search symbols, you’ll need to use regular expressions (regex for short).

Throughout this post, I’ll make use three stringr functions: str_subset, str_detect, and str_extract, and a subset of the sentences vector.

library(stringr)

sentences <- sentences[1:10]
sentences

 [1] "The birch canoe slid on the smooth planks." 
 [2] "Glue the sheet to the dark blue background."
 [3] "It's easy to tell the depth of a well."     
 [4] "These days a chicken leg is a rare dish."   
 [5] "Rice is often served in round bowls."       
 [6] "The juice of lemons makes fine punch."      
 [7] "The box was thrown beside the parked truck."
 [8] "The hogs were fed chopped corn and garbage."
 [9] "Four hours of steady work faced us."        
[10] "A large size in stockings is hard to sell."

str_subset(sentences, "of") # keep only elements with a match

[1] "It's easy to tell the depth of a well."
[2] "Rice is often served in round bowls."  
[3] "The juice of lemons makes fine punch." 
[4] "Four hours of steady work faced us."

str_detect(sentences, "of") # TRUE when an element matches, FALSE otherwise

 [1] FALSE FALSE  TRUE FALSE  TRUE  TRUE FALSE FALSE  TRUE FALSE

str_extract(sentences, "of") # pull out matching substrings

 [1] NA   NA   "of" NA   "of" "of" NA   NA   "of" NA

Special characters

The following characters (all of which are explained below) have special meanings and can’t be searched literally.

. \ | ( ) [ { ^ $ * + ?

For instance, a dot matches with any character, which explains the following output.

str_extract(sentences, ".")

 [1] "T" "G" "I" "T" "R" "T" "T" "T" "F" "A"

In order to match these metacharacters, precede them with two slashes, like so:

str_extract(sentences, "\\.")

 [1] "." "." "." "." "." "." "." "." "." "."

Position and relative position

To specify that a substring comes at the beginning of a string, use “^”. To specify that it comes at the end, use “$”.

str_subset(fruit, "^re")

[1] "redcurrant"

str_subset(fruit, "er$") # note order

[1] "bell pepper"  "chili pepper" "cucumber"

As mentioned above, a dot indicates that substrings are separated by an arbitrary character.

str_extract(sentences, "s.o")

 [1] "smo" NA    NA    NA    "s o" NA    NA    NA    "s o" "sto"

Character sets

Use brackets to allow multiple options for the character to be matched.

str_subset(sentences, "[oe]n")

[1] "The birch canoe slid on the smooth planks."
[2] "These days a chicken leg is a rare dish."  
[3] "Rice is often served in round bowls."      
[4] "The juice of lemons makes fine punch."

str_extract(sentences, "[oe]n")

 [1] "on" NA   NA   "en" "en" "on" NA   NA   NA   NA

Ranges of letters and numbers are allowed.

str_subset(sentences, "[a-j]o")

[1] "Rice is often served in round bowls."       
[2] "The box was thrown beside the parked truck."
[3] "The hogs were fed chopped corn and garbage."
[4] "Four hours of steady work faced us."

str_extract(sentences, "[a-j]o")

 [1] NA   NA   NA   NA   "bo" NA   "bo" "ho" "ho" NA

Inside of brackets, “^” represents negation.

str_extract(sentences, "[^a-j]o")

 [1] "no" "to" "to" NA   " o" " o" "ro" NA   "Fo" "to"

Character classes

It’s also possible to specify classes of characters. “\d” matches any digit and “\w” matches and word character (a-z, A-Z, 0-9, and underscore), while “\D” and “\W” will match anything except digits and word characters, respectively. Many other classes are available. Enter ?regex for a full list.

The role of “\” in Quarto

If you write “\d” in a Quarto document, it won’t render properly. This is because Quarto interprets the slash as an escape character. To actually render this string, use “\\d” instead.

Similarly, to render a slash, use \\.

Matching whitespace

Use \\s for space, \\t for tab, and \\n for a new line.

str_subset(sentences, "e\\sb")

[1] "The birch canoe slid on the smooth planks." 
[2] "Glue the sheet to the dark blue background."
[3] "The box was thrown beside the parked truck."

Repetition

Use curly braces to indicate how many times in a row a character must appear.

str_subset(sentences, "e{2}")

[1] "Glue the sheet to the dark blue background."

Use “+” to indicate at least one occurrence, possibly more.

str_subset(sentences, "she+t")

[1] "Glue the sheet to the dark blue background."

To indicate a character is optional, use “?”. For instance, the next command detects both “the” and “often”.

str_extract(sentences, "th?e")

 [1] "the" "the" "te"  NA    "te"  NA    "the" NA    "te"  NA

Finally, “*” indicates an optional character that may occur more than once.

str_extract(sentences, "she*")

 [1] NA     "shee" NA     "sh"   NA     NA     NA     NA     NA     NA

Notice that these symbols come after the characters they refer to, unlike “\” which comes before.

Combining substrings with `|`

Use the pipe to indicate an “or” statement. Expressions on either side are grouped by default.

str_subset(sentences, "chicken|hog")

[1] "These days a chicken leg is a rare dish."   
[2] "The hogs were fed chopped corn and garbage."

You can still group using parentheses, though.

str_subset(sentences, "(chicken|hog)s")

[1] "The hogs were fed chopped corn and garbage."

Want more?

If something here isn’t clear, there’s a good chance you’ll find an explanation in my vid on the subject:

Discrete probability calculations in R

Andrew Gard — Mon, 15 Sep 2025 05:00:00 GMT

In R, functions that perform probabilities calculations follow a consistent structure:

Probability mass functions (pmfs) start with the letter “d”. Use such a function to compute for any of interest.
Cumulative distribution functions (cdfs) start with the letter “p”. Use such a function to compute .
Inverse cdfs start with the letter “q”. For a given probability , they determine the least such that .
Functions to generate random values start with the letter “r”.

The rest of the function name is a shortened version of the distribution name:

Distribution	Probability	Cumulative	Inverse	Random
Bin	dbinom()	pbinom()	qbinom()	rbinom()
Geom	dgeom()	pgeom()	qgeom()	rgeom()
NB	dnbinom()	pnbinom()	qnbinom()	rnbinom()
Hyp	dhyper()	phyper()	qhyper()	rhyper()
Pois	dpois()	ppois()	qpois()	rpois()

In case some of these distributions aren’t familiar to you:

The binomial distribution models the total number of success in Bernouilli trials (identical and independent trials, each with only two possibly outcomes). The probability of success in each trial is .
The geometric distribution models the number of failures in a sequence of Bernouilli trials prior to the first success.
The negative binomial distribution models the number of failures in a sequence of Bernouilli trials prior to the success.
The hypergeometric distribution models the number of successes in a sample of size when selection is done without replacement from a pool that includes successes and failures.

For instance, imagine a student guessing randomly on a 12-question quiz where each question has 4 possible answers. The probability that they get exactly 3 questions right is computed using dbinom().

dbinom(3, 12, .25)

[1] 0.2581036

Similarly, the probability that they get at most 3 questions right is given by

pbinom(3, 12, .25)

[1] 0.6487786

If you need the probability that they get at least 3 questions right, add a lower.tail argument, like so:

pbinom(3, 12, .25, lower.tail = FALSE)

[1] 0.3512214

qbinom() reverses the logic of pbinom(), finding the number of successes with a specified cumulative probability. Said differently, qbinom() identifies percentiles. For instance, we might wonder how many questions the child would have to get right to do at least as well as 80% of randomly-guessing quiz takers.

qbinom(.80, 12, .25)

[1] 4

Notice how the arguments of these functions follow a common pattern: first the value/percentile of interest, then the parameters, which come in a consistent order. This pattern continues to hold for rbinom(), which generates a specified number of random values

set.seed(0) # For reproducibility

rbinom(10, 12, .25)

 [1] 5 2 2 3 5 2 5 5 4 3

All of R’s probability functions are vectorized, meaning that they can perform multiple calculations at once. For instance, the next line computes the probability of obtaining exactly Butterfingers when randomly grabbing 5 candy bars from a bowl with 8 Butterfingers and 10 Snickers. Note that .

dhyper(0:5, 8, 10, 5)

[1] 0.029411765 0.196078431 0.392156863 0.294117647 0.081699346 0.006535948

As you’d expect, these probabilities all add up to one.

Some caution is needed when working with the geometric and negative binomial distributions, both of which consider the number of failures occurring before a fixed number of successes. Some textbooks and computational tools define these distributions in terms on the total number of trials needed rather than the total number of failures, so some translation may be needed. Fortunately,

so the two formulations differ only in the addition or subtraction of the parameter .

Example. A basketball player makes 85% of their free throws. If they shoot until they make 5 shots, what is the probability that 7 shots are needed?

Solution. Making 5 out of 7 shots requires exactly 2 misses, so the probability is

dnbinom(2, 5, .85)

[1] 0.1497505

You might consider trying the next problem on your own before reading my solution.

Example. Every day, a new author has a 10% chance of selling a copy of their ebook. Assume that purchases are independent of one another and that there are never multiple sales in a single day.

Find the probability that the first purchase occurs on the 10 day.
Find the probability that the second purchase occurs during the second week (days 8-14).

Solution. Let be the number of days that pass before the first purchase and let be the number of purchase-less days before the second. Then has a geometric distribution and has a negative binomial distribution. In each case, .

If 10 trials are needed for a single success, then 9 failures must have occurred, so we compute dgeom(9, .10) = 0.038742
If between 8 and 14 days are needed for 2 sales, then between 6 and 12 days must have occurred without sales. pnbinom(12, 2, .10) - pnbinom(5, 2, .10) = 0.2656765

Prefer to have this all clearly explained in a short vid? I’ve got you covered:

Andrew Gard, Ph.D

Working with factors in R

Factor, character, and other vector types

Relabeling factors

Rearranging levels

Reordering levels using a second variable

Ordered factors

Want more?

Regular expressions for R users

Special characters

Position and relative position

Character sets

Character classes

The role of “\” in Quarto

Matching whitespace

Repetition

Combining substrings with |

Want more?

Discrete probability calculations in R

Combining substrings with `|`