Column Selection and Renaming

1. Selecting Columns You Want with select()

When you import a dataset, it often contains more columns than you need for a specific analysis. The select() function is your primary tool for creating a new data frame containing only the columns you are interested in.

The basic idea is to pipe your data frame into select() and then list the names of the columns you want to keep.

# A conceptual example
my_data %>%
  select(column_A, column_B, column_C)

This takes my_data and returns a new data frame that contains only column_A, column_B, and column_C in that order.

select() is more powerful than just picking columns by name. You can also:

• Select a range of columns: Use the colon (:) to select all columns between a start and end point (e.g., column_A:column_D).
• Exclude columns: Use the negation operator (!) to keep all columns except the ones you specify (e.g., !column_to_remove). You may also see the minus sign (-) used for this in older code, but ! is the modern standard.

The following reading, from a book on reproducible medical research, provides excellent examples of these techniques using a dataset relevant to your interests.

2. Powerful Selections with Helper Functions

What if your dataset has 200 columns and you want to select all variables related to "blood pressure"? Typing them all out would be tedious and error-prone. To solve this, select() works with a set of "tidyselect" helper functions that let you choose columns based on patterns in their names.

The most common helpers are:

• starts_with("preop_"): Selects columns whose names begin with "preop_".
• ends_with("_days"): Selects columns whose names end with "_days".
• contains("bp"): Selects columns that have "bp" anywhere in their name.

You can combine these helpers to build sophisticated selections. For instance, select(patient_id, starts_with("treatment_"), contains("score")) would create a dataset with the patient ID, all treatment-related columns, and all score-related columns.

3. Renaming Columns with rename()

Clear column names are crucial for readable code and understandable results. You'll often find that raw data uses cryptic abbreviations (e.g., Pt_ID, wbc_k) that need to be clarified. The rename() function is designed for this.

Unlike select(), which discards columns you don't mention, rename() keeps all columns and simply changes the names of the ones you specify.

The syntax is rename(new_name = old_name). It is critical to remember this order: the new name comes first.

my_data %>%
  rename(patient_id = Pt_ID,
         white_blood_cell_count = wbc_k)

You can also rename columns as part of a select() call. This is useful when you want to select and rename in a single step: select(patient_id = Pt_ID, diagnosis). This would select the Pt_ID and diagnosis columns, renaming the first one to patient_id in the process.

The following video provides a clear, step-by-step demonstration of both selecting and renaming columns.

4. Let's Practice

It's time to combine these functions in a practical exercise. We'll use the blood_storage dataset from the medicaldata package, which contains data from a study on the effect of red blood cell storage duration on patient outcomes.

Open your clinical-trial-practice RStudio Project and create a new R script named 08-select-rename.R.

1. Load packages and data. Add this code to your script and run it. We'll need tidyverse for dplyr and medicaldata for the dataset.

   library(tidyverse)
   library(medicaldata) # You may need to install this first: install.packages("medicaldata")
   
   
   
   
   # Look at the raw data
   glimpse(blood_storage)
   

   Take a moment to look at the column names. You'll notice some are clear (like Age) while others are more cryptic (like RBC.Age.Group).

2. Your Task: Select and Rename Columns.
   Your goal is to create a new, cleaner data frame called blood_storage_clean. This new data frame should be the result of a single piped sequence that does the following:

   • Starts with the original blood_storage data.
   • Selects only the columns from Recurrence to sGS, the Age column, and all columns that contain "Therapy".
   • Excludes the BN column from the selection.
   • Renames the following columns:
     • RBC.Age.Group to rbc_age_group
     • PreopPSA to preop_psa
     • PreopTherapy to preop_therapy

   Add your code to the script to perform these steps.

   Click here to see the solution

   blood_storage_clean <- blood_storage %>%
     select(Recurrence:sGS, Age, contains("Therapy"), !BN) %>%
     rename(
       rbc_age_group = `RBC.Age.Group`, # Note the backticks for names with special characters like '.'
       preop_psa = PreopPSA,
       preop_therapy = PreopTherapy
     )
   
   
   
   
   # View the result
   glimpse(blood_storage_clean)
   

   A note on the backticks ( ): R can be particular about column names that contain spaces or special characters like periods. While dplyr is often flexible, it's a good practice to surround such names with backticks to avoid ambiguity.

This exercise mirrors a common workflow: taking a raw dataset, focusing on the variables of interest, and cleaning up the names to prepare for analysis.

Conclusion

In this lesson, you've learned two of the most fundamental dplyr verbs for shaping your data. By thoughtfully selecting and renaming columns, you create a dataset that is not only smaller and more manageable but also far more intuitive to work with.

Key Takeaways:

• select() subsets your data frame by choosing columns to keep. It can select columns by name, by range (:), or by exclusion (!).
• Helper functions like starts_with(), ends_with(), and contains() make select() incredibly powerful for working with large datasets.
• rename() changes column names while keeping all columns. The syntax is rename(new_name = old_name).
• These functions, when chained together with the pipe %>%, form the basis of a clean and readable data wrangling workflow.

Preview of the Next Lesson:
Now that you can manage your columns, the next step is to manage your rows. In the next lesson, we will explore the filter() function, which allows you to subset observations (rows) based on specific conditions. This will give you the ability to ask questions like "Which patients are over 65?" or "Which observations have no missing data?".