Reading a CSV file in R takes one line of code: read.csv(“yourfile.csv”). The function loads your data into a data frame, which is the table-like structure R uses for almost every analysis. The harder part is what happens before and after that single line: putting the file in a place R looks at by default, telling R what to do with column headers, dealing with missing values, and handling files that use semicolons or tabs instead of commas.
This guide covers the full workflow for beginners. The first half walks through how to read a CSV correctly using both read.csv() from base R and read_csv() from the tidyverse. The second half covers the 6 most common errors students hit, with the exact fix for each one.
Where to put your CSV file before reading it
Place your CSV file inside your R project folder, and your code finds it without a long file path. That single rule prevents most of the file-not-found errors students lose hours to.
R looks for files inside a place called the working directory. By default, the working directory is wherever your R session started, which is rarely where your data actually sits. Three commands handle this:
getwd() # shows your current working directorysetwd("/path/to/your/folder") # changes it to a folder you chooselist.files() # shows what files R sees in that folder
Run getwd() first. If the path it returns is your project folder, your file goes there. If the path is something like /Users/yourname or C:/Users/yourname/Documents, change the working directory using setwd(), or move the file into the folder R is already pointing at.
A cleaner approach for any assignment is the here package, which finds your project folder automatically. Install it once with install.packages(“here”), then load it with library(here). File paths now look like here(“data”, “yourfile.csv”), and the code keeps working even if the project folder moves to a new computer.
Read a CSV file with read.csv() from base R
Base R reads a CSV in one line:
students <- read.csv("students.csv")
The arrow <- assigns the loaded data to an object called students. The name on the left is yours to choose. Common student choices are data, df, or whatever describes the dataset, like survey or sales.
Once the file is loaded, three commands confirm it worked:
head(students) # shows the first 6 rowsstr(students) # shows the structure: column types and a previewsummary(students) # shows summary statistics for each column
If head() returns rows that match your file, the import worked. If the columns look misaligned or the first row of your data has been mistaken for column names (or vice versa), one of the arguments below fixes it.
The most useful arguments of read.csv()
Five arguments handle nearly every CSV variation you encounter as a student:
students <- read.csv(file = "students.csv",header = TRUE, # the first row contains column namessep = ",", # comma is the column separatorna.strings = c("", "NA", "-9999"), # treat these as missingstringsAsFactors = FALSE, # keep text as text, not factorsstrip.white = TRUE # remove accidental spaces around values)
Set header = FALSE if your file has no column names. Change sep to “;” for European-format files, or “\t” for tab-separated files. The na.strings argument tells R which values represent missing data, so they become NA instead of being misread as text or as the number -9999.
Read a CSV file with read_csv() from the tidyverse
The tidyverse version is read_csv() from the readr package. It runs faster than read.csv(), keeps text as text by default, and produces cleaner output. For most modern student work, this is the better starting point.
library(readr)students <- read_csv("students.csv")
Notice the underscore: read_csv() with an underscore is the tidyverse function, while read.csv() with a dot is base R. Mixing the two trips up almost every beginner at least once.
Three differences worth knowing
First, read_csv() returns a tibble instead of a regular data frame. A tibble prints only the first 10 rows in the console, shows the column type under each column name, and refuses to print rows that do not fit on the screen. It works the same as a data frame for analysis, but the output is easier to read.
Second, read_csv() guesses column types by reading the first 1,000 rows. The console shows what it guessed:
Rows: 250 Columns: 5-- Column specification --------------------------------------Delimiter: ","chr (2): name, countrydbl (3): age, score, year
If a column is guessed wrong (a numeric ID column read as a number, when leading zeros matter), specify the type using col_types:
students <- read_csv("students.csv",col_types = cols(student_id = col_character(),age = col_integer()))
Third, read_csv() reports parsing problems through problems(). After reading, run problems(students) to see any rows where the data did not match the expected type. This is invaluable for catching messy real-world data before it breaks downstream analysis.
Six common CSV errors students hit (and the fix for each)
The errors below cover the great majority of CSV import problems in beginner R coursework. Each section shows the exact error message R produces, the cause, and the one-line fix.
Error 1: cannot open file – no such file or directory
What R prints
Error in file(file, "rt") : cannot open the connectionIn addition: Warning message:In file(file, "rt") :cannot open file 'students.csv': No such file or directory
What is happening
R is looking in the wrong folder for your file. The working directory and the location of the file do not match. This is the most common CSV error for beginners by a wide margin, and it has nothing to do with your code being wrong.
How to fix it
Run getwd() to see where R is looking. Run list.files() to see what files R sees in that folder. If your file is not there, either move it into that folder or use setwd() to point R at the right folder. The here package is the cleanest long-term solution.
Common variants of this error: a typo in the filename, the wrong extension (students.CSV instead of students.csv on case-sensitive Linux or Mac systems), or an invisible space at the end of the filename when copied from File Explorer or Finder.
Error 2: data appears in one column instead of several
What you see
The file loads without an error, but head() shows everything crammed into a single column with semicolons or tabs visible inside it:
name.age.country
1 Alice;22;UK
2 Bob;19;France
3 Carla;25;Spain
What is happening
The CSV file uses a different separator than the comma R expects. Files exported from European versions of Excel use semicolons because the comma is reserved for decimal places. Files from older databases sometimes use tabs.
How to fix it
students <- read.csv("students.csv", sep = ";") # semicolon-separatedstudents <- read.csv("students.csv", sep = "\t") # tab-separated
For European-format files where commas are decimal separators (so 3,14 means 3.14), use read.csv2() instead, which sets sep = “;” and dec = “,” automatically.
Error 3: special characters look broken (Müller becomes Müller)
What you see
name country1 Müller Germany2 Lefèvre France3 ÃNorgren Sweden
What is happening
The file is encoded in one character set (often Windows-1252 or Latin-1), but R is reading it in another (usually UTF-8). The mismatch turns accented letters into garbled sequences. This often shows up with names from European, Latin American, or Asian datasets.
How to fix it
students <- read.csv("students.csv", fileEncoding = "Latin-1")# or for tidyverse:students <- read_csv("students.csv", locale = locale(encoding = "Latin-1"))
If you do not know the encoding, the readr package has a guesser:
guess_encoding("students.csv")
That returns a list of likely encodings ranked by confidence. Use the top result.
Error 4: missing values stay as text instead of NA
What you see
Cells that ought to be missing are showing up as empty strings, the literal text “NA”, or sentinel numbers like -9999:
age score1 22 782 "" 65 # empty string, not NA3 19 -9999 # sentinel value, not NA
What is happening
R only treats values as missing if it knows what to look for. By default, read.csv() recognises only NA and empty fields. Other markers for missingness, like -9999, N/A, ?, or a single space, get treated as real data.
How to fix it
students <- read.csv("students.csv",na.strings = c("", "NA", "N/A", "-9999", "?"))
Pass every value that means missing into the na.strings vector. R then converts each one to NA during import. Catching this at the import step is much faster than fixing it column by column afterwards.
Error 5: header row was treated as data (or data was treated as header)
What you see
Your column names appear as the first row of data:
V1 V2 V31 name age country2 Alice 22 UK3 Bob 19 France
Or the opposite, where the first row of real data has been adopted as column names.
What is happening
The header argument is set wrong. read.csv() assumes the first row contains column names by default. read.table() assumes the opposite. Files exported from some databases come with no header row at all.
How to fix it
# File with no header rowstudents <- read.csv("students.csv", header = FALSE)
# After loading, give the columns proper namesnames(students) <- c("name", "age", "country")
Always run head(students) right after import. If the column names look wrong or the first row of data looks like a header, set header appropriately and re-import.
Error 6: more columns than header names (extra columns appearing)
What R prints
Error in read.table(file = file, header = header, sep = sep, ...) :more columns than column names
What is happening
Some rows in the file have more values than the header row promised. The usual cause is a comma inside a text value that was not enclosed in quotation marks. For example, an address field containing 123 Main St, Apt 5 gets split into two columns instead of staying together as one.
How to fix it
Open the CSV in a plain text editor (not Excel, which silently fixes the file in memory). Find the row that has extra commas and check whether values containing commas have proper quotation marks around them. The fix is usually one of three:
# 1. Force R to fill in missing values rather than throw an errorstudents <- read.csv("students.csv", fill = TRUE)
# 2. Use a different quote character if the file uses single quotesstudents <- read.csv("students.csv", quote = "'")
# 3. Switch to read_csv() from readr, which handles edge cases betterstudents <- readr::read_csv("students.csv")
If none of these work, the file itself is malformed. Open it, fix the offending rows manually, save, and re-import.
A quick diagnostic checklist for CSV import problems
Work through these 6 checks in order whenever a CSV refuses to load correctly:
1. Run getwd() and list.files() to confirm R sees the file. If it does not, change the working directory or move the file.
2. Open the file in a plain text editor. Confirm the separator (comma, semicolon, tab) and check whether the file has a header row.
3. After import, run head(), str(), and summary(). Confirm the column count, the column types, and that special characters render correctly.
4. Check the missing values. Run sum(is.na(students)) to count NAs. If the count is zero but you expected missing values, fix the na.strings argument.
5. For tidyverse imports, run problems(students) to see any rows where parsing failed.
6. If accented characters look wrong, set fileEncoding or locale = locale(encoding = …) and re-import.
Once your data is loaded correctly
With the CSV loaded into a clean data frame, the rest of your assignment workflow continues from there. If your next step is fitting a regression on the imported data, Linear regression in R walks through the full process from lm() to interpreting the summary() output. If you hit the “could not find function” error while loading the readr package, Fix the ‘Could Not Find Function’ Error in R covers the six common causes of that one.
Reading a CSV correctly is the foundation of every data analysis assignment in R. Once the file loads cleanly, with the right column types and the right handling of missing values, almost every downstream problem is easier to solve.
Stuck on a CSV that refuses to load?
R Programming, RStudio and Statistics Homework Help from a verified expert means you share your screen with the person fixing the import, see exactly what is going wrong with the file, and get the data ready for analysis without losing the rest of your evening to a broken encoding or a misplaced separator. You pay 50 percent up front and the remaining 50 percent only after your data loads cleanly into R.