How to Create New Variables in R with mutate() and case_when()

Often, you may need to create a new variable in a data frame in R based on complex conditional criteria. Fortunately, implementing this conditional assignment is straightforward using the mutate() and case_when() functions from the dplyr package.

This comprehensive tutorial demonstrates several examples of how to utilize these functions together, starting with the construction of our foundational example dataset:

#create data frame
df <- data.frame(player = c('a', 'b', 'c', 'd', 'e'),
                 position = c('G', 'F', 'F', 'G', 'G'),
                 points = c(12, 15, 19, 22, 32),
                 rebounds = c(5, 7, 7, 12, 11))

#view data frame
df

  player position points rebounds
1      a        G     12        5
2      b        F     15        7
3      c        F     19        7
4      d        G     22       12
5      e        G     32       11

Understanding the Power of mutate()

The primary role of the mutate() function is straightforward yet powerful: it facilitates the addition of new variables to a dataset. When applied to a data frame, mutate() evaluates expressions row-by-row, ensuring that the new column aligns perfectly with the dimensions of the existing data structure. This operation is non-destructive, meaning the original data remains untouched unless you explicitly overwrite the original variable name, making it a safe and predictable tool for data transformation workflows.

In the context of the Tidyverse, mutate() is most commonly used in conjunction with the pipe operator (%>%), allowing for fluid, step-by-step data manipulation. This chaining mechanism enables analysts to perform several transformation steps sequentially, such as filtering rows, summarizing data, and finally creating a new variable, all within a single, highly readable chain of commands. The syntax requires specifying the name of the new variable followed by an equals sign, and then the expression used to define its values. When that expression involves complex, multi-layered conditions, we rely on case_when() to formulate that expression.

It is important to recognize that mutate() can also utilize newly created variables immediately within the same function call. If you define Variable A and then immediately refer to Variable A when defining Variable B within the same mutate() call, R will execute the definition of A first, making the resulting values available for the calculation of B. However, when complex conditional logic is required—for example, assigning grade categories based on numerical score ranges—case_when() is the superior and more explicit method for defining the relationship between the input and the output columns.

Mastering Conditional Logic with case_when()

While R provides traditional methods for conditional logic (like ifelse() or nested if-else structures), the case_when() function, also part of dplyr, offers a vastly improved solution for handling multiple, sequential conditions. It evaluates pairs of logical expressions and resulting values. The structure is intuitive: condition_1 ~ result_1, condition_2 ~ result_2, .... The function proceeds through these conditions sequentially, and crucially, once a condition evaluates to TRUE for a specific row, case_when() assigns the corresponding result and stops evaluating further conditions for that row. This order of operations is critical and must be considered when defining ranges or overlapping criteria.

Unlike ifelse(), which is limited to binary outcomes (one true result, one false result), case_when() can handle an arbitrary number of cases, making it ideal for creating categorical or binned variables. Furthermore, it is vectorized, meaning it operates efficiently across the entire column simultaneously, avoiding the performance bottlenecks associated with iterating through rows using standard R loops. This vectorization is a core reason why case_when() is the preferred method for conditional data manipulation within the modern R environment.

A key feature of case_when() is its flexibility in terms of data types. The results (the right-hand side of the tilde ~) must all be of the same type, whether they are character strings, numeric values, or logical values. If types are mismatched, case_when() will throw an error or attempt coercion, which can lead to unexpected results. Additionally, it is essential to define a catch-all condition to handle any rows that do not meet any of the specified criteria. This is typically achieved by setting the final condition to TRUE ~ default_value, ensuring that no rows are assigned an undesired missing value (NA) simply because they fell outside the defined cases. This practice significantly improves the robustness of the data transformation logic.

Example 1: Categorization Based on a Single Numeric Variable

One of the most frequent uses of conditional variable creation is binning—taking a continuous variable and dividing it into distinct categorical levels. In this example, we aim to create a new variable named scorer that classifies players as ‘low’, ‘med’, or ‘high’ based solely on their points column. This requires careful consideration of the sequence of conditions within case_when().

When defining numerical ranges, it is crucial to use strict inequalities (< or >) or ensure conditions are ordered correctly due to the sequential evaluation of case_when(). If we define the categories from the lowest range upwards, we ensure exclusivity. For example, if a player scores 12 points, they satisfy points < 15. Since case_when() stops evaluation after the first true condition, this player is correctly assigned ‘low’, even though 12 is also technically less than 25 and 35.

The following code block demonstrates this structure. We pipe the data frame df into mutate(), where we define the new column scorer using the logical framework established by case_when():

library(dplyr)

#define new variable 'scorer' using mutate() and case_when()
df %>%
  mutate(scorer = case_when(points < 15 ~ 'low',
                           points < 25 ~ 'med',
                           points < 35 ~ 'high'))

  player position points rebounds scorer
1      a        G     12        5    low
2      b        F     15        7    med
3      c        F     19        7    med
4      d        G     22       12    med
5      e        G     32       11   high

Analyzing the output, Player ‘a’ (12 points) is ‘low’. Player ‘b’ (15 points) falls into the second category, points < 25, resulting in ‘med’. This confirms that case_when() provides an efficient and easily interpretable method for translating numerical thresholds into meaningful descriptive categories, which is often a preliminary step in complex statistical modeling.

Example 2: Complex Logic Using Multiple Character Variables

The true power of case_when() emerges when we need to define categories based on non-numeric variables or combinations of variables using logical operators like OR (|) and AND (&). In this scenario, we create a variable called type, which attempts to categorize players into roles like ‘starter’, ‘backup’, or ‘reserve’ based on specific player identifiers or their position.

This example demonstrates how logical conditions can involve exact matching of character strings. Note the use of the OR operator (|) to group multiple players into the same category. For instance, the first condition checks if the player identifier is ‘a’ OR ‘b’. If either is true, the player is classified as ‘starter’. We must ensure consistency in the data type of the results; since the conditions are based on character columns, the output must also be character strings.

Observe the conditional structure below. Player ‘e’ does not match the ‘a’/’b’ starter condition or the ‘c’/’d’ backup condition. Therefore, they proceed to the final case, position == 'G', and are assigned ‘reserve’. This highlights the importance of the sequential evaluation of case_when(), where earlier conditions take precedence. If Player ‘c’ was a ‘G’, they would still be labeled ‘backup’ because the condition player == 'c' is evaluated first.

library(dplyr)

#define new variable 'type' using mutate() and case_when()
df %>%
  mutate(type = case_when(player == 'a' | player == 'b' ~ 'starter',
                            player == 'c' | player == 'd' ~ 'backup',
                            position == 'G' ~ 'reserve'))

  player position points rebounds    type
1      a        G     12        5 starter
2      b        F     15        7 starter
3      c        F     19        7  backup
4      d        G     22       12  backup
5      e        G     32       11 reserve

This demonstrates the versatility of combining mutate() and case_when() for complex, non-numeric assignments. When dealing with real-world datasets, this approach is often used for feature engineering, where raw identifiers or simple categorical fields are translated into richer, more meaningful features for machine learning models.

Example 3: Calculating Value Based on Interacting Numeric Variables

Perhaps the most complex application involves using multiple numeric variables simultaneously to calculate a derived value. Here, we define a variable called valueAdded, which assigns a numerical score (2, 4, 6, 7, or 9) based on thresholds derived from both points and rebounds. This requires the use of the logical AND operator (&) within the conditions to ensure both parts of the criteria are met.

When using AND conditions, the logic becomes highly specific. For example, the first condition requires a player to have 15 points or less (points <= 15) AND 5 rebounds or less (rebounds <= 5) to receive a score of 2. If a player meets the points threshold but exceeds the rebound threshold (like player ‘b’), they skip the first condition and move to the second: points <=15 & rebounds > 5, receiving a score of 4.

It is essential to maintain the correct sequential ordering. Notice how the conditions are defined to cover distinct quadrants of the points/rebounds plane. The final condition, points >=25, acts as a high-performance catch-all for the highest tier, as any player exceeding 25 points is automatically assigned the highest value of 9, regardless of their rebound count. Defining these interacting conditions clearly within case_when() minimizes potential for logical errors.

library(dplyr)

#define new variable 'valueAdded' using mutate() and case_when()
df %>%
  mutate(valueAdded = case_when(points <= 15 & rebounds <=5 ~ 2,
                                points <=15 & rebounds > 5 ~ 4,
                                points < 25 & rebounds < 8 ~ 6,
                                points < 25 & rebounds > 8 ~ 7,
                                points >=25 ~ 9))

  player position points rebounds valueAdded
1      a        G     12        5          2
2      b        F     15        7          4
3      c        F     19        7          6
4      d        G     22       12          7
5      e        G     32       11          9

This detailed example underscores the efficiency gained by using vectorized conditional assignment over traditional programming loops. It allows for complex, multi-dimensional decision-making to be executed rapidly across an entire dataset, producing the desired numeric outcome valueAdded which quantifies player performance based on a composite metric.

Best Practices: Handling Defaults and Missing Values (NA)

A critical aspect of using case_when() robustly is the management of default outcomes. If a row does not satisfy any of the provided logical conditions, case_when() will assign a missing value (NA) to the new variable for that row. While NA might sometimes be the intended result, it is often better practice to explicitly define what should happen in these residual cases.

To ensure every row receives a defined value, analysts should always include a final, catch-all condition. This is achieved using the constant logical value TRUE as the condition. Since TRUE is always true, it will catch any row that has fallen through all preceding, more specific conditions. The result assigned to this final case then becomes the default value for all unclassified observations. This explicit definition greatly reduces ambiguity and prevents unexpected propagation of missing data.

Consider the potential need to handle explicit missing values in the input data. If any of the columns used in the conditions (e.g., points or rebounds) contain NAs, the logical comparison (e.g., points < 15) will also evaluate to NA, causing the row to be skipped by specific conditions. If you want NA inputs to result in a specific category (e.g., ‘Unknown’), you must include an explicit check, such as is.na(points) ~ 'Unknown', placed early in the case_when() structure to ensure it is evaluated before other conditional logic.

By defining a default case, we ensure data integrity and make the code immediately clear regarding assumptions about unclassified data points. This proactive approach to data quality is essential in large-scale data analysis projects.

Summary and Next Steps in R Data Transformation

This comprehensive guide has demonstrated how the combined capabilities of mutate() and case_when() offer an elegant, powerful solution for creating conditionally defined variables in R. We explored various scenarios, ranging from simple numeric binning to complex assignments based on multiple interacting variables, all within the efficient framework provided by the dplyr package.

The key takeaways for maximizing the effectiveness of these functions include: always defining conditional logic in a sequential manner within case_when(), ensuring that the results are of a consistent data type, and proactively handling all possible outcomes by including a final TRUE ~ default_value condition. Mastering these techniques is indispensable for anyone performing serious data cleaning, feature engineering, or statistical pre-processing in the R programming language.

Building upon the foundational skills of variable creation, analysts should next explore related data manipulation techniques within the Tidyverse. The ability to rename, remove, and filter data structures complements variable creation, forming a complete toolkit for preparing data frames for analysis. These subsequent steps often follow conditional variable creation in a typical data workflow.

For further refinement of your data manipulation skills in R, consider exploring these related topics:

• How to Rename Columns in R
• How to Remove Columns in R
• How to Filter Rows in R