Strings & Factors

PSY 410: Data Science for Psychology

Dr. Sara Weston

2026-05-11

The Power Play

Something new in the team challenge

The top 2 teams on the scoreboard right now get a one-time strategic choice:

Option A — Boost: Add +3 points to your own team’s total

Option B — Sabotage: Remove 2 points from each of two other teams of your choice

Choices are final. First place picks first.

This is the Power Play — a mid-term twist to keep things interesting. Show the scoreboard first (as usual), then reveal this slide. Give teams a minute to react, then have the top 2 teams announce their choices live. If a team is targeted by both, they lose 4 total. Teams can’t go below 0. This should take about 5 minutes and generate some fun energy. Don’t belabor it — announce, choose, update the scoreboard, move on.

Strings: The basics

How many majors are in this dataset?

id	major
1	Psychology
2	psychology
3	Psych
4	PSYCHOLOGY
5	Biology
6	biology
7	Bio

How many majors are in this dataset?

R says 7. You meant 2.

The problem is inconsistent text — different cases, abbreviations, trailing spaces. Today we learn to fix that.

Start by showing the first slide (the table) and asking students “How many majors are in this dataset?” Let them look at the table and answer before revealing that R sees 7 unique values. This is the hook — the gap between what humans see and what R sees motivates the entire session. Spend ~2 minutes here.

What are strings?

Strings are text data — anything in quotes:

participant_name <- "Jane Doe"
diagnosis <- "Major Depressive Disorder"
feedback <- "The task was confusing"

The stringr package (part of tidyverse) gives you tools for working with strings. All stringr functions start with str_.

Emphasize the naming convention: all stringr functions start with str_, so autocomplete in RStudio is very helpful. Students can type str_ and browse available functions. This is a good time to remind them about the tab-completion habit.

Creating and combining strings

first <- "Jane"
last <- "Doe"

# Combine strings
str_c(first, last)           # No space

[1] "JaneDoe"

str_c(first, last, sep = " ")  # With space

[1] "Jane Doe"

# Combine with other text
str_c("Participant: ", first, " ", last)

[1] "Participant: Jane Doe"

# Glue is even easier (from the glue package)
library(glue)
glue("Participant: {first} {last}")

Participant: Jane Doe

Move quickly through str_c() — students will use it occasionally but glue() is more intuitive. Show both so they recognize str_c() in others’ code, but recommend glue() for their own work. If students ask: glue is loaded automatically with tidyverse in newer versions, but loading it explicitly does not hurt.

String length

responses <- c("Yes", "No", "Maybe", "I don't know")

str_length(responses)

[1]  3  2  5 12

Useful for checking free-response data quality:

# Flag very short responses
tibble(responses) |>
  mutate(too_short = str_length(responses) < 3)

# A tibble: 4 × 2
  responses    too_short
  <chr>        <lgl>    
1 Yes          FALSE    
2 No           TRUE     
3 Maybe        FALSE    
4 I don't know FALSE    

Changing case

messy_data <- c("PSYCHOLOGY", "Biology", "psychology", "BIOLOGY", "Psychology")

str_to_lower(messy_data)

[1] "psychology" "biology"    "psychology" "biology"    "psychology"

str_to_upper(messy_data)

[1] "PSYCHOLOGY" "BIOLOGY"    "PSYCHOLOGY" "BIOLOGY"    "PSYCHOLOGY"

str_to_title(messy_data)

[1] "Psychology" "Biology"    "Psychology" "Biology"    "Psychology"

Essential for cleaning survey data!

This is one of the most important slides in the deck. str_to_lower() alone solves a huge number of data cleaning problems. Run the code live and ask: “If you had to pick just one of these three functions, which would you use for cleaning survey data?” Answer: str_to_lower(), because it makes everything comparable regardless of how participants typed it.

Trimming whitespace

Survey data often has extra spaces:

messy_responses <- c("  Yes", "No  ", "  Maybe  ")

str_trim(messy_responses)         # Remove leading/trailing

[1] "Yes"   "No"    "Maybe"

str_squish(messy_responses)       # Also reduce internal spaces

[1] "Yes"   "No"    "Maybe"

Students often ask the difference between str_trim() and str_squish(). str_trim() only removes leading and trailing whitespace; str_squish() also collapses multiple internal spaces into one. For survey data, str_trim() is usually sufficient. Trailing spaces from Qualtrics exports are very common and invisible to the eye — this is why str_trim() matters.

Psychology example: Cleaning survey responses

survey <- tibble(
  major = c("  Psychology", "BIOLOGY  ", "psychology", "Biology", "  sociology")
)

survey |>
  mutate(
    major_clean = str_to_lower(str_trim(major))
  )

# A tibble: 5 × 2
  major          major_clean
  <chr>          <chr>      
1 "  Psychology" psychology 
2 "BIOLOGY  "    biology    
3 "psychology"   psychology 
4 "Biology"      biology    
5 "  sociology"  sociology  

This is the payoff slide for the opening example. Walk through it step by step: “First we trim the spaces, then we lowercase everything.” Point out the nesting — str_to_lower wraps str_trim. Students could also pipe these with |> but nesting is fine for two functions. After cleaning, ask: “How many unique majors would R see now?” This connects directly back to the hook.

Detecting patterns

str_detect() checks if a pattern is present:

feedback <- c(
  "The task was clear",
  "I found it confusing",
  "Very clear instructions",
  "Somewhat confusing"
)

str_detect(feedback, "clear")

[1]  TRUE FALSE  TRUE FALSE

Detecting patterns in filter()

str_detect() returns TRUE/FALSE — exactly what filter() needs:

tibble(feedback) |>
  filter(str_detect(feedback, "clear"))

# A tibble: 2 × 1
  feedback               
  <chr>                  
1 The task was clear     
2 Very clear instructions

This is the workhorse pattern: pair str_detect() with filter() to keep only rows whose text matches. Connects back to last session on logicals. Students will use this constantly for things like “find all participants who mentioned anxiety in their open-ended response.”

Case-insensitive detection

Patterns are case-sensitive by default:

str_detect("Clear instructions", "clear")  # FALSE

[1] FALSE

Make them case-insensitive with regex(ignore_case = TRUE):

str_detect("Clear instructions", regex("clear", ignore_case = TRUE))

[1] TRUE

The regex() wrapper with ignore_case is essential for real survey data where you cannot control capitalization. Students will forget this and wonder why their str_detect() misses matches — remind them that case-sensitivity is the default and they need to opt in to ignoring case.

Replacing text

Open-ended responses often have repeated words:

responses <- c(
  "very very tired",
  "very stressed and very anxious",
  "I felt fine"
)

# Replace the first match in each string
str_replace(responses, "very", "extremely")

[1] "extremely very tired"                "extremely stressed and very anxious"
[3] "I felt fine"                        

# Replace every match in each string
str_replace_all(responses, "very", "extremely")

[1] "extremely extremely tired"               
[2] "extremely stressed and extremely anxious"
[3] "I felt fine"                             

Run both lines and have students compare the output side by side. The first call only swaps the first “very” in each string — the second “very” stays put. str_replace_all() catches both. Stress that “first match” means first within each element of the vector, not just the first element.

Multiple replacements

Imagine clinical notes with diagnosis abbreviations scattered inside the text:

notes <- c(
  "Patient presented with MDD symptoms",
  "Differential: MDD vs GAD",
  "Family history of OCD and GAD"
)

Multiple replacements

Pass a named vector to str_replace_all() to expand them wherever they appear:

str_replace_all(notes, c(
  "MDD" = "Major Depressive Disorder",
  "GAD" = "Generalized Anxiety Disorder",
  "OCD" = "Obsessive-Compulsive Disorder"
))

[1] "Patient presented with Major Depressive Disorder symptoms"                       
[2] "Differential: Major Depressive Disorder vs Generalized Anxiety Disorder"         
[3] "Family history of Obsessive-Compulsive Disorder and Generalized Anxiety Disorder"

This is what str_replace_all() does that case_when() can’t: it edits substrings inside longer text, not whole values. case_when() would only work if every cell were exactly “MDD” or “GAD” — here the abbreviations are buried in clinical notes. This is the realistic version of working with free-text data.

Extracting parts of strings

participant_ids <- c("PSY001", "PSY002", "PSY010", "PSY123")

# Extract substring by position
str_sub(participant_ids, start = 4)  # Get everything after position 3

[1] "001" "002" "010" "123"

# Extract numbers
str_extract(participant_ids, "\\d+")  # \d+ means "one or more digits"

[1] "001" "002" "010" "123"

When you need more: Regular expressions

Regular expressions (regex) are powerful pattern matching tools.

Examples:

• \\d matches digits
• \\s matches whitespace
• . matches any character
• + means “one or more”
• * means “zero or more”

Note

Regex is powerful but complex. For this course, stick to simple patterns. When you need more, check R4DS Ch 14 or regex101.com.

Do not go deep on regex — this is a “know it exists” slide. Students only need to know that \d matches digits and that patterns can be more powerful than literal text. If anyone asks for more, point them to regex101.com where they can test patterns interactively. Transition: “You have enough string tools now to clean real data. Let’s practice.”

Pair coding break

Your turn: Clean text data

You have messy survey responses:

messy_survey <- tibble(
  id = 1:5,
  major = c("  PSYCHOLOGY", "biology  ", "Psychology", "BIOLOGY", "sociology  "),
  comment = c(
    "Great study!",
    "too long",
    "  Very interesting  ",
    "CONFUSING INSTRUCTIONS",
    "I enjoyed this"
  )
)

Your turn: Clean text data

1. Clean major to lowercase with no extra spaces
2. Clean comment to title case with no extra spaces
3. Create a logical column is_negative that is TRUE if the comment contains “long” or “confusing” (case-insensitive)
4. Filter to only negative comments

Time: 10 minutes

Give 10 minutes. Common issues to watch for: (1) students forgetting to nest str_to_lower(str_trim(…)) or doing them in the wrong order (order doesn’t matter here, but they may think it does), (2) for the is_negative column, students need the pipe (|) inside the regex pattern for “or” — remind them this is different from the logical OR operator, (3) students forgetting regex(ignore_case = TRUE). Walk through the solution afterward, emphasizing the cleaning-then-filtering workflow.

Solution: Clean text data

messy_survey |>
  mutate(
    # clean up major variable
    major = str_to_lower(major),
    major = str_trim(major),
    # clean up comment variable
    comment = str_trim(comment),
    comment = str_to_title(comment),
    # make is_neg column
    is_negative = str_detect(comment, "Long") | str_detect(comment, "Confusing"),
    is_negative = str_detect(comment, regex("long", ignore_case = T)) |
      str_detect(comment, regex("confusing", ignore_case = T))
  ) |>
  filter(is_negative)

Factors

What are factors?

Factors are R’s way of representing categorical data with a fixed set of possible values.

# A character vector
major_char <- c("Psychology", "Biology", "Biology", "Psychology")

# A factor
major_fct <- factor(major_char)
major_fct

[1] Psychology Biology    Biology    Psychology
Levels: Biology Psychology

Notice the Levels line — those are the possible categories.

Run this code live. The key thing students should notice is the “Levels:” line in the output — that is what makes a factor different from a plain character vector. Emphasize that levels define the complete set of valid categories, even if some do not appear in the data. This matters for plots and statistical models.

Why use factors?

1. Memory efficient — R stores categories once, not repeatedly
2. Prevent typos — Can’t accidentally add invalid categories
3. Control order — Specify the order for plots and tables
4. Model requirements — Many statistical models require factors

Creating factors

condition <- c("Control", "Treatment", "Treatment", "Control")

# Let R choose levels (alphabetical)
factor(condition)

[1] Control   Treatment Treatment Control  
Levels: Control Treatment

# Specify levels explicitly
factor(condition, levels = c("Control", "Treatment"))

[1] Control   Treatment Treatment Control  
Levels: Control Treatment

Emphasize the difference: without specifying levels, R defaults to alphabetical order. With explicit levels, you control the order. For most psychology data, you want explicit levels because alphabetical order rarely makes conceptual sense (e.g., “Control” should come before “Treatment” even though it does alphabetically by coincidence).

Order matters!

likert <- c("Agree", "Disagree", "Strongly Agree", "Agree", "Strongly Disagree")

# Alphabetical order (default)
factor(likert)

[1] Agree             Disagree          Strongly Agree    Agree            
[5] Strongly Disagree
Levels: Agree Disagree Strongly Agree Strongly Disagree

# Logical order
factor(likert, levels = c(
  "Strongly Disagree", "Disagree", "Agree", "Strongly Agree"
))

[1] Agree             Disagree          Strongly Agree    Agree            
[5] Strongly Disagree
Levels: Strongly Disagree Disagree Agree Strongly Agree

Why order matters: Example

This two-slide sequence is the most persuasive argument for factors. Show the alphabetical plot first and ask “What is wrong with this chart?” Students will immediately see that the Likert order is scrambled. Then show the fixed version. This aha moment makes the factor concept stick.

survey_data <- tibble(
  response = c("Agree", "Disagree", "Strongly Agree", "Agree",
               "Strongly Disagree", "Agree", "Disagree")
)

# Without factor ordering
ggplot(survey_data, aes(x = response)) +
  geom_bar() +
  labs(title = "Alphabetical order (confusing!)") +
  theme_minimal()

Why order matters: Example

Fixed with factor ordering

survey_data <- survey_data |>
  mutate(
    response = factor(response, levels = c(
      "Strongly Disagree", "Disagree", "Agree", "Strongly Agree"
    ))
  )

ggplot(survey_data, aes(x = response)) +
  geom_bar() +
  labs(title = "Logical order (much better!)") +
  theme_minimal()

Fixed with factor ordering

Forcats: Factor tools

The forcats package (part of tidyverse) provides functions for working with factors.

All forcats functions start with fct_.

Key functions:

• fct_relevel() — manually reorder levels
• fct_reorder() — reorder by another variable
• fct_infreq() — order by frequency
• fct_recode() — rename levels
• fct_collapse() — combine levels

Emphasize the naming convention: all forcats functions start with fct_, just like stringr functions start with str_. This makes them easy to find with autocomplete. You do not need to load forcats separately — it is part of tidyverse. Skim the list; each function gets its own slide next.

fct_relevel(): Manual reordering

education <- factor(c("High School", "Bachelor's", "Master's", "High School"))
education

[1] High School Bachelor's  Master's    High School
Levels: Bachelor's High School Master's

# Put in logical order
fct_relevel(education, "High School", "Bachelor's", "Master's")

[1] High School Bachelor's  Master's    High School
Levels: High School Bachelor's Master's

fct_reorder(): Order by another variable

fct_reorder() is arguably the most useful forcats function for data visualization. It reorders factor levels by the values of another variable. In the therapy example, conditions are ordered by mean improvement, making the bar chart immediately readable. Students will use this frequently in assignments and the final project.

Extremely useful for plots!

therapy <- tibble(
  condition = c("CBT", "Control", "Mindfulness", "Medication"),
  mean_improvement = c(12, 3, 8, 10)
)

therapy |>
  mutate(condition = fct_reorder(condition, mean_improvement))

# A tibble: 4 × 2
  condition   mean_improvement
  <fct>                  <dbl>
1 CBT                       12
2 Control                    3
3 Mindfulness                8
4 Medication                10

fct_reorder() in action

therapy |>
  mutate(condition = fct_reorder(condition, mean_improvement)) |>
  ggplot(aes(x = mean_improvement, y = condition)) +
  geom_col() +
  labs(
    title = "Treatment effectiveness (ordered by improvement)",
    x = "Mean improvement",
    y = "Treatment condition"
  ) +
  theme_minimal()

fct_reorder() in action

fct_infreq(): Order by frequency

diagnosis <- c("Depression", "Anxiety", "Depression", "Other",
               "Depression", "Anxiety", "Anxiety", "Depression")

# Order from most to least common
fct_infreq(factor(diagnosis))

[1] Depression Anxiety    Depression Other      Depression Anxiety    Anxiety   
[8] Depression
Levels: Depression Anxiety Other

fct_infreq() in plots

tibble(diagnosis = factor(diagnosis)) |>
  mutate(diagnosis = fct_infreq(diagnosis)) |>
  ggplot(aes(y = diagnosis)) +  # Note: y instead of x to read easily
  geom_bar() +
  labs(
    title = "Most common diagnoses first",
    x = "Count",
    y = "Diagnosis"
  ) +
  theme_minimal()

fct_infreq() in plots

fct_recode(): Rename levels

major <- factor(c("Psych", "Bio", "Bio", "Psych", "Soc"))

fct_recode(major,
  "Psychology" = "Psych",
  "Biology" = "Bio",
  "Sociology" = "Soc"
)

[1] Psychology Biology    Biology    Psychology Sociology 
Levels: Biology Psychology Sociology

fct_collapse(): Combine levels

Useful for grouping rare categories:

diagnosis <- factor(c("MDD", "GAD", "OCD", "PTSD", "Panic Disorder",
                      "MDD", "GAD", "Social Anxiety"))

fct_collapse(diagnosis,
  Depression = "MDD",
  Anxiety = c("GAD", "OCD", "PTSD", "Panic Disorder", "Social Anxiety")
)

[1] Depression Anxiety    Anxiety    Anxiety    Anxiety    Depression Anxiety   
[8] Anxiety   
Levels: Anxiety Depression

fct_collapse() is useful when you have too many levels for meaningful analysis. In psychology, you often collapse rare diagnosis categories into “Other” or group specific disorders into broader categories. Note that OCD is grouped under Anxiety here, which reflects older DSM-IV classification — this could spark a good discussion about how coding decisions reflect theoretical assumptions.

Psychology example: Recoding demographics

demo_data <- tibble(
  age_group = c("18-25", "26-35", "18-25", "36-45", "26-35", "46+"),
  education = c("HS", "BA", "BA", "MA", "HS", "PhD")
)

demo_data

# A tibble: 6 × 2
  age_group education
  <chr>     <chr>    
1 18-25     HS       
2 26-35     BA       
3 18-25     BA       
4 36-45     MA       
5 26-35     HS       
6 46+       PhD      

Recoding demographics

demo_data |>
  mutate(
    age_group = factor(age_group, levels = c("18-25", "26-35", "36-45", "46+")),
    education = fct_recode(factor(education),
      "High School" = "HS",
      "Bachelor's"  = "BA",
      "Master's"    = "MA",
      "Doctorate"   = "PhD"
    )
  )

# A tibble: 6 × 2
  age_group education  
  <fct>     <fct>      
1 18-25     High School
2 26-35     Bachelor's 
3 18-25     Bachelor's 
4 36-45     Master's   
5 26-35     High School
6 46+       Doctorate  

Dropping unused levels

After filtering, factors keep old levels:

all_diagnoses <- factor(c("Depression", "Anxiety", "Other"))
just_depression <- all_diagnoses[all_diagnoses == "Depression"]
just_depression

[1] Depression
Levels: Anxiety Depression Other

Use fct_drop() to remove them:

fct_drop(just_depression)

[1] Depression
Levels: Depression

This is a common gotcha. After filtering, factors remember their old levels, which can create empty bars in plots or confuse statistical models. fct_drop() solves it. Students will encounter this when they subset data and then try to plot — the empty categories show up as blank bars.

Common factor issues

Problem 1: Factors created from numbers

age_factor <- factor(c(25, 30, 25, 40))
mean(age_factor)  # Error! It's not numeric anymore

[1] NA

Solution: Convert back to numeric carefully:

as.numeric(as.character(age_factor))  # Correct way

[1] 25 30 25 40

This is a classic trap. Students sometimes accidentally convert numeric columns to factors (e.g., when reading CSV files with read.csv instead of read_csv). The key lesson: as.numeric() on a factor gives you the internal level codes (1, 2, 3…), not the original values. You must go through as.character() first. This mistake has caused real errors in published research.

Common factor issues

Problem 2: Factors behave differently than strings

colors <- factor(c("red", "blue"))

# Can't just add new values
colors[3] <- "green"  # This creates NA!
colors

[1] red  blue <NA>
Levels: blue red

Solution: Convert to character first, or use fct_expand() to add levels.

Light text analysis

What did you say about data?

On the class survey, you described your relationship with data in 1–2 words. Let’s see what you said.

class_survey <- read_csv(
  "https://raw.githubusercontent.com/sjweston/datasci410/refs/heads/main/data/class_survey.csv"
)

class_survey |>
  select(data_words) |>
  head(10)

# A tibble: 10 × 1
   data_words                  
   <chr>                       
 1 frustrating and overwhelming
 2 novel                       
 3 novice                      
 4 hopeful                     
 5 work-in-progress            
 6 big and scary               
 7 necessary                   
 8 theory adjacent             
 9 unrequited love             
10 neutral                     

Transition: “We’ve been cleaning strings and ordering factors. Now let’s do something fun with text data — your text data.” Remind students this is the same URL pattern they used in Session 10 — read_csv() can take a URL directly, no download needed. Show the raw responses. Students will laugh at some of the answers. This motivates the next step: how do we summarize open-ended text?

Tokenizing text with tidytext

unnest_tokens() splits text into individual words:

words <- class_survey |>
  select(data_words) |>
  unnest_tokens(word, data_words)

words

# A tibble: 77 × 1
   word        
   <chr>       
 1 frustrating 
 2 and         
 3 overwhelming
 4 novel       
 5 novice      
 6 hopeful     
 7 work        
 8 in          
 9 progress    
10 big         
# ℹ 67 more rows

Each row is now a single word.

Explain: unnest_tokens takes a column of text and turns each word into its own row. The first argument is what to call the new column, the second is the source column. This is the foundation of text analysis — you can’t count words until they’re in separate rows.

Words alone aren’t enough

words |>
  anti_join(stop_words, by = "word") |>
  count(word, sort = TRUE) |>
  slice_head(n = 5)

# A tibble: 5 × 2
  word            n
  <chr>       <int>
1 complicated     2
2 curious         2
3 love            2
4 adjacent        1
5 barely          1

Most words appeared just once. Counting alone won’t tell us much.

But every word carries a feeling — positive, negative, neutral. Can we measure that?

Run the count live so students see the flat distribution — a couple words at 2, most at 1. Ask: “What can we conclude from this?” Answer: not much. Then pivot: “But each word carries a feeling. Let’s measure the feelings instead of the words.”

How does our class feel about data?

tidytext ships with the Bing lexicon — ~6,800 English words tagged positive or negative. We can inner_join() to keep only the words our class used and the lexicon recognized.

words |>
  inner_join(get_sentiments("bing"), by = "word") |>
  count(sentiment) |>
  ggplot(aes(x = sentiment, y = n, fill = sentiment)) +
  geom_col() +
  scale_fill_manual(values = c("negative" = "#c0392b", "positive" = "#27ae60")) +
  labs(
    title = "How our class feels about data",
    x = NULL, y = "Words"
  ) +
  theme_minimal(base_size = 14) +
  theme(legend.position = "none")

Walk through the pipeline: inner_join keeps only the words tagged in the lexicon (most filler words drop out — “the”, “psychology”, “data” itself), then count by sentiment, then plot. The bars are close — about 17 negative to 14 positive. Resist the urge to declare a verdict here. Instead, plant the seed: “It looks roughly balanced. But should we trust that? Let’s look at the actual words.”

How does our class feel about data?

Which words drove the score?

words |>
  inner_join(get_sentiments("bing"), by = "word") |>
  count(word, sentiment, sort = TRUE)

# A tibble: 26 × 3
   word        sentiment     n
   <chr>       <chr>     <int>
 1 good        positive      3
 2 complicated negative      2
 3 interesting positive      2
 4 love        positive      2
 5 brutal      negative      1
 6 confused    negative      1
 7 derogatory  negative      1
 8 difficult   negative      1
 9 frustrating negative      1
10 fun         positive      1
# ℹ 16 more rows

Read carefully — did the lexicon get every word right?

This is the setup. Notice “good” leads the positive list with 3 hits, and “great”, “love” are also tagged positive. Don’t explain why yet — push them to look at the original phrases on the next slide.

Where did “good” actually come from?

unnest_tokens(..., drop = FALSE) keeps the source phrase so we can spot-check:

class_survey |>
  select(data_words) |>
  unnest_tokens(word, data_words, drop = FALSE) |>
  inner_join(get_sentiments("bing"), by = "word") |>
  filter(word %in% c("good", "great", "love")) |>
  mutate(data_words = str_trunc(data_words, 35))

# A tibble: 6 × 3
  data_words                          word  sentiment
  <chr>                               <chr> <chr>    
1 unrequited love                     love  positive 
2 not great                           great positive 
3 not good                            good  positive 
4 i have never coded before and it... good  positive 
5 good                                good  positive 
6 love-hate                           love  positive 

Out of 8 “scored” tokens, the lexicon got one right.

This is the payoff. Walk down the table column by column: “not good” → bing scores “good” as positive (negation lost). “not great” → same problem. “unrequited love” → “love” tagged positive (the whole phrase is sad). “master, slave” → split mechanically into one positive + one negative, ignoring that it’s a metaphor about being controlled by data. “love-hate” → only “love” is here (positive); “hate” was already in the table on the previous slide as negative — one phrase contributed to both columns. Only the standalone “good” actually means “good.” So while the bars on the previous chart looked roughly balanced (17 vs 14), the real sentiment is much more negative. The takeaway: sentiment lexicons can’t see negation, sarcasm, metaphor, or context. In real research, you spot-check by reading a sample. Connect forward: “Assignment 6 will ask you to make exactly these calls.”

End-of-deck exercise

Practice: Clean and visualize survey data

You have messy Likert scale data:

likert_data <- tibble(
  question = rep(c("Q1", "Q2", "Q3"), each = 10),
  response = sample(c("strongly agree", "Agree", "NEUTRAL",
                      "disagree", "Strongly Disagree"), 30, replace = TRUE)
)

1. Clean the response variable to title case
2. Convert response to a factor with logical ordering
3. Create a bar chart showing response counts for each question
4. Use facet_wrap() to make separate panels for each question
5. Bonus: Use fct_infreq() to order responses by overall frequency
6. A6 preview — given an open_responses tibble with a response column, tokenize it and find the most common non-stopwords:

library(tidytext)
open_responses |>
  unnest_tokens(word, response) |>
  anti_join(stop_words, by = "word") |>
  count(word, sort = TRUE)

Give ~10 minutes. This exercise ties together strings and factors: students must first clean the text (str_to_title), then convert to a factor with proper ordering, then plot. Watch for students who forget to clean before converting to factor, which creates duplicate levels like “agree” and “Agree.” The facet_wrap step is review from earlier visualization sessions. If students finish early, the fct_infreq() bonus is a good stretch goal, and step 6 previews the tidytext workflow they’ll need for A6 Part 5 — emphasize that unnest_tokens() + anti_join(stop_words) is the standard pattern, no regex required.

Solution: Clean and visualize survey data

likert_data_clean <- likert_data |>
  mutate(
    # Clean to title case
    response = str_to_title(response),

    # Convert to factor with logical order
    response = factor(response, levels = c(
      "Strongly Disagree", "Disagree", "Neutral", "Agree", "Strongly Agree"
    ))
  )

# Basic plot with facets
ggplot(likert_data_clean, aes(x = response)) +
  geom_bar() +
  facet_wrap(~question) +
  labs(title = "Survey responses by question",
       x = "Response", y = "Count") +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))

# Bonus: order by frequency
likert_data_clean |>
  mutate(response = fct_infreq(response)) |>
  ggplot(aes(x = response)) +
  geom_bar() +
  facet_wrap(~question) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))

Wrapping up

String functions cheat sheet

Function	Purpose
str_c()	Combine strings
str_length()	Get string length
str_to_lower(), str_to_upper()	Change case
str_trim(), str_squish()	Remove whitespace
str_detect()	Find pattern
str_replace(), str_replace_all()	Replace pattern
str_sub()	Extract substring

Factor functions cheat sheet

Function	Purpose
factor()	Create a factor
fct_relevel()	Manually reorder levels
fct_reorder()	Order by another variable
fct_infreq()	Order by frequency
fct_recode()	Rename levels
fct_collapse()	Combine levels
fct_drop()	Remove unused levels

Key takeaways

1. Strings are text — use stringr::str_*() functions to manipulate
2. Always clean string data — case, whitespace, typos
3. Factors are categorical data with fixed levels
4. Factor order matters for plots and tables
5. Use forcats (fct_*()) to manipulate factors
6. Order factors logically — not alphabetically
7. When in doubt, check the data type with class() or glimpse()

Before next class

📖 Read:

• R4DS Ch 18: Missing values

✅ Do:

• Start Assignment 6
• Check your final project data for string/factor issues
• Practice cleaning demographic variables

The one thing to remember

Messy categories turn into messy results. str_to_lower() and factor() are your first line of defense.

See you Wednesday for missing data!

Remind students that Assignment 6 is now assigned and Assignment 5 was due Sunday. The reading for next class is R4DS Ch 18 on missing values. Preview that missing data is one of the most common issues in psychology research — attrition, skipped questions, lost waves — and that we’ll learn how to detect and handle it. Encourage students to check their final project data for string and factor issues this week.