Data Import

PSY 410: Data Science for Psychology

Dr. Sara Weston

2026-04-15

Getting real data into R

Your data isn’t inside a package

So far we’ve used datasets that were already loaded in R — mpg, flights, bfi.

But your thesis data isn’t sitting inside a package. It’s a CSV on your desktop, an Excel file from your advisor, or a Qualtrics export with 200 columns named Q1, Q2, Q3…

Today we learn how to get it into R — and what to check when things don’t import cleanly.

This opening connects to students’ real frustration — they know R can do things, but they haven’t been able to use their own data yet. Ask: “How many of you have data sitting in a CSV or Excel file right now?” Most hands should go up. That’s the motivation. This is a shorter, more practical deck than Session 5, so the pace can be a bit faster.

Reading CSV files

read_csv() — your workhorse

# The basic pattern
my_data <- read_csv("path/to/file.csv")

• Part of the readr package (loaded with tidyverse)
• Returns a tibble, not a base R data frame
• Smarter about guessing column types than read.csv()

Emphasize the file path — this is where students get stuck most often. Common issues: wrong working directory, file not in the project folder, using backslashes on Windows. If you’re doing a live demo, show what happens when the path is wrong (a clear error message). Remind them about the RStudio Files pane for navigating to files.

Why not read.csv()?

	read_csv()	read.csv()
Package	readr (tidyverse)	base R
Returns	tibble	data.frame
Speed	Much faster	Slower
Type guessing	Better	Converts strings to factors
Consistent	Yes	Depends on options

Always use read_csv() in this class.

Students will encounter read.csv() in StackOverflow answers and older textbooks. The key practical difference: read.csv() silently converts character columns to factors, which causes confusing errors later. read_csv() (underscore) doesn’t do this. Emphasize the underscore vs. period distinction — it’s an easy typo. If a student’s code uses read.csv(), it will still work, but they may hit unexpected behavior.

What read_csv() does automatically

# It figures out column types from the first 1000 rows
my_data <- read_csv("survey.csv")

# It tells you what it decided:
glimpse(my_data)

Types it recognizes: dbl (number), chr (text), lgl (TRUE/FALSE), date, dttm (date-time)

When the guess is wrong

Sometimes R guesses wrong — especially with:

• ID numbers (should be character, not numeric)
• Zip codes, phone numbers
• Dates in unusual formats
• Columns that are mostly empty

# Check for problems after reading
my_data <- read_csv("survey.csv")
problems(my_data)  # Shows any parsing issues

The participant ID example resonates most with psychology students. If IDs are “001”, “002”, “003”, R reads them as numbers 1, 2, 3 — losing the leading zeros. Ask: “Why does that matter?” It matters for merging datasets later, and it changes how the ID behaves in plots. Always run problems() after importing — make this a habit students build now.

Specifying column types

# Tell read_csv() what types to use
my_data <- read_csv("survey.csv",
  col_types = cols(
    participant_id = col_character(),  # Don't treat as number
    age = col_integer(),
    gender = col_character(),
    score = col_double()
  )
)

Frame this as: “When R guesses wrong, you override it.” Students don’t need to memorize every col_* function — the important ones are col_character() and col_double(). Mention that you can specify types for just the problem columns and let R guess the rest (using .default = col_guess() inside cols()). Spend ~2 minutes here.

col_types shortcuts

Shortcut	Type
"c"	character
"d"	double
"i"	integer
"l"	logical
"D"	date
"?"	let R guess

# Compact version
read_csv("survey.csv", col_types = "cdiccc?")

Handling messy headers

Real data often has ugly column names:

# Skip rows at the top (metadata, notes)
read_csv("messy.csv", skip = 2)

# Only read specific rows
read_csv("messy.csv", n_max = 100)

# Rename columns after import
my_data <- read_csv("messy.csv") |>
  rename(age = `Age (years)`, score = `Total Score`)

Point out the backticks around column names with spaces or special characters. Students will see this a lot with Qualtrics exports and Excel files. The backtick syntax confuses people — explain that R needs them because “Age (years)” isn’t a valid R name. The janitor::clean_names() function is a nice shortcut here if you want to mention it briefly, though it’s not required for this course.

Missing values

By default, read_csv() recognizes these as NA:

NA, N/A, NaN, "" (empty), ".", "NULL"

# Add your own NA strings
read_csv("survey.csv", na = c("NA", "N/A", "-999", ""))

Psychology datasets often use -999 or 99 as missing value codes!

This is critical for psychology data. Many students will have worked with SPSS datasets that use -999 as a missing value code. If you don’t catch these at import, they’ll silently corrupt your means and standard deviations. Ask: “What happens to your mean anxiety score if one participant has -999 instead of NA?” The answer is devastating — and that’s the point. Handling missing values at import prevents downstream errors.

Writing CSV files

# Save your cleaned data
write_csv(my_cleaned_data, "data/cleaned_survey.csv")

Save intermediate cleaned files — don’t re-clean every time you start R.

This is a workflow habit, not a coding lesson. Emphasize the practical benefit: cleaning data takes time, so save the cleaned version and read that in future scripts. This also connects to reproducibility (Session 7) — your cleaning script documents exactly what you did to the raw data. Transition to the pair exercise: “Now let’s practice the full import-check-fix workflow.”

Pair coding break

Your turn: 10 minutes

I’ve created a messy CSV file for you. Download it here. With a partner:

1. Read it back in with read_csv() — what types does R guess?
2. Fix the missing values: -999 and "N/A" should be NA
3. Rename the columns to clean snake_case names
4. What does problems() show you?

Set a 10-minute timer. Make sure students have downloaded the CSV file before starting — this is a common bottleneck. Circulate and check that students are using read_csv() (underscore, not period). The most common mistake is forgetting to include all the NA strings in the na argument. After time is up, walk through the solution and ask: “Did anyone get something different from problems()?” Remind students to upload their code to Canvas.

Before we move on

📤 Upload your code to Canvas for participation credit. Paste what you have into today’s in-class submission — it doesn’t need to work perfectly.

Excel files

readxl::read_excel()

Excel is everywhere in psychology. The readxl package handles it:

library(readxl)  # Or just use readxl:: directly

# Read the first sheet
my_data <- read_excel("survey_results.xlsx")

# Read a specific sheet
my_data <- read_excel("survey_results.xlsx", sheet = "Demographics")

# Read a specific range
my_data <- read_excel("survey_results.xlsx",
  sheet = "Scores",
  range = "A1:F50"
)

Note that readxl is installed with tidyverse but not loaded by library(tidyverse) — you need to load it separately or use the readxl:: prefix. Students often ask “Why not just save as CSV first?” That’s a reasonable approach, but read_excel() handles it directly and avoids data loss from CSV conversion (e.g., Excel date formatting). Spend ~3 minutes on Excel; it’s familiar territory for most students.

Excel pitfalls

Things that look fine in Excel but break in R:

• Merged cells — R sees them as one value + empty cells
• Colors as data — R can’t read cell colors
• Multiple tables on one sheet — use range to isolate them
• Formatted numbers — “1,234” might read as text

Tip

The best fix is usually to clean the Excel file first, or use range to read just the clean part.

Students who have worked in labs may recognize these problems. The “colors as data” point usually gets a laugh — some labs really do use cell highlighting to code conditions. The practical takeaway: Excel is a display tool, not a data storage tool. If you receive an Excel file with these issues, the cleanest fix is often to open it in Excel, fix the formatting, and re-save before importing.

Listing sheet names

# See what sheets are in a file
excel_sheet_names("survey_results.xlsx")

Useful when you don’t know the file structure yet.

Other file formats

SPSS and SAS files

Psychology labs often have data in SPSS (.sav) or SAS formats:

library(haven)

# Read SPSS
spss_data <- read_sav("study.sav")

# Read SAS
sas_data <- read_sas("study.sas")

These return tibbles, just like read_csv().

Many students will encounter SPSS files in their research labs. The key message is: you don’t need SPSS installed to read .sav files. This is a selling point for R — it can read anything. Move through this slide quickly (~1 minute) unless students have specific questions.

A note about SPSS labels

SPSS files often have variable labels and value labels:

# Labels are stored as attributes
attr(spss_data$gender, "label")   # "Participant Gender"
attr(spss_data$gender, "levels")  # 1="Male", 2="Female"

# To drop labels and work with plain values:
library(haven)
spss_data <- zap_labels(spss_data)

This is a “just so you know” slide. Students don’t need to master haven labels right now, but they should know that SPSS files carry metadata that can cause unexpected behavior (e.g., a column that looks numeric but is actually a labelled vector). If they hit weird errors after importing a .sav file, zap_labels() is the quick fix. Move on fairly quickly.

Getting data out of Qualtrics

The most common workflow in psychology:

1. In Qualtrics: Download → CSV (or use the API — advanced)
2. The export includes metadata rows at the top — skip them:

# Qualtrics CSVs typically have 3 header rows
qualtrics_data <- read_csv("my_survey_export.csv", skip = 2)

3. Clean up the automatic column names (they’re ugly)
4. Handle the timestamp columns if you need them

Note

The first two rows after the header contain Qualtrics’ own descriptions. skip = 2 gets past them. Always check with glimpse() after importing.

This will be the most practically relevant slide for many students. Qualtrics exports are notoriously messy — the first two rows after the header are Qualtrics metadata (question text, import IDs), not data. If you don’t skip them, your first two “participants” will be nonsense strings. If time permits, show a real Qualtrics export on screen so students can see the three-row header structure. Spend ~3 minutes here.

Putting it together

A realistic import workflow

# 1. Read the file
raw_data <- read_csv("qualtrics_export.csv",
  skip = 2,
  na = c("", "N/A", "-999")
)

# 2. Check what you got
glimpse(raw_data)
problems(raw_data)

# 3. Rename columns
clean_data <- raw_data |>
  rename(
    id = ResponseId,
    age = Q1,
    condition = Q2
  )

# 4. Fix types if needed
clean_data <- clean_data |>
  mutate(
    id = as.character(id),
    age = as.numeric(age)
  )

# 5. Save the cleaned version
write_csv(clean_data, "data/clean_survey.csv")

Walk through this as a complete workflow — this is the template students should internalize. Emphasize the order: read, check, rename, fix types, save. Students often want to skip step 2 (checking), but that’s where you catch problems before they propagate. This workflow is essentially what Assignment 3 will ask them to do end to end. Spend ~3 minutes walking through each step.

Get a head start: Assignment 3

Try this mini-challenge before next class:

# 1. Import the messy CSV from the pair exercise
messy <- read_csv("data/messy_survey.csv", na = c("", "NA", "-999", "N/A"))

# 2. Check for problems
problems(messy)

# 3. Fix at least one column type issue with col_types or
#    readr::parse_number()

# 4. Save your cleaned version
write_csv(clean, "data/clean_survey.csv")

Assignment 3 will have you do this end to end with real messy data.

This is individual work for the remaining class time (~10 minutes). Students who finished the pair exercise quickly can extend their earlier code. If time is short, frame this as homework: “Start this now and finish before next class.” Mention that Assignment 3 builds directly on this workflow, so the practice now will pay off.

Solution

Wrapping up

The import toolkit

Function	What it does
read_csv()	Read CSV files
write_csv()	Save CSV files
read_excel()	Read Excel files
read_sav()	Read SPSS files
problems()	Check for import issues
col_types	Control column types

Before next class

📖 Read:

• R4DS Ch 9: Layers

✅ Practice:

• Try importing a CSV or Excel file you have lying around
• Check problems() — does it flag anything?
• Practice renaming messy column names

Key takeaways

1. read_csv() is your default — it’s faster and smarter than read.csv()
2. Check your imports — glimpse() and problems() are your friends
3. Name your missing values — psychology data loves -999
4. Excel is tricky — use readxl and be suspicious of formatting
5. Save cleaned files — don’t re-clean every time

If you need to cut anything from this deck for time, the col_types shortcuts slide and the separate Excel “listing sheet names” slide are the most skippable. The core message students should leave with: always check your imports, and handle missing values at import time.

The one thing to remember

Your analysis is only as good as your import. Check it before you trust it.

Next time: Layers & Aesthetics

Remind students of the reading for next class (R4DS Ch 9: Layers). Next session moves back to ggplot2 with a deeper dive into layers and aesthetics. Preview: “Now that you can import and reshape your own data, we’ll learn how to build more sophisticated visualizations with it.”