Content

Scripts

One of the advantages of using R to clean and analyse data is the use of scripts. Scripts are where you can save code used to manipulate a data set for analysis. As a reminder, a script is different from the console; the script is where you save code for later use, while the console is where you would run the code. If you would like to run code saved in a script, you will need to copy it or “send” it to the console. In RStudio, the script is in the top left window, while the console is the bottom left window.

Having a script is advantageous because:

Scripts reduces human error.
Scripts keeps a record of manipulations on data sets (again, reducing errors and data corruption, or reliance on your own memory).
Scripts are easily shareable and reproducible.
A change can be introduced in the analysis pipeline without re-doing the whole process.

A good way to structure scripts are the following steps. There is no obligation to follow this convention for your own scripts, but I would highly suggest sticking to it to begin with:

Load in any packages you need to use (more on this below).
Import the data you will be working with (more on this below).
Prepare the data for analysis (e.g., cleaning your data ready for analysis).
Analyse your data (e.g., conduct statistical tests, create visualisations of the data, etc. More on this in future Demonstrations).

A new script can be created in RStudio by selecting the following in the drop-down menus:

File >> New File >> R Script

You can also save and open R scripts under the File tab. Scripts are opened in the text editor window (top left window) of RStudio.

A handy thing to know is that you can make comments on your code in a script by using the ‘#’ symbol. Anything after this symbol on a line will not be treated as code. This is handy for making notes to yourself about what your code does, or making your code more readable. Here are some examples of using comments:

#This line will not run because it is commented out.

x <- 2 #This line save the object 'x' as the number 2.

There are no limits to the number of comments you can have in a script, so if it helps you remember what each bit of code does, add as many comments as you want!

Packages

Base R comes with a lot of in-built functions, but one of the great things about R is that there is a large community writing functions and including them in packages for free. Packages are like add-ons that can expand the number of functions you can use in R. There are thousands of packages that different R users have created to solve many different kinds of problems. If you want to do something in R, it is highly likely there’s already a package for that.

Packages have to be downloaded and installed onto your computer before you can use them in R. You can install packages from the main R repository (CRAN) using the install.packages() function.

There is an important distinction between installing a package and loading a package. Installing a package is done using install.packages(). This is like installing an app on your smartphone: you only have to do it once and the app will remain installed until you remove it. Likewise, when you install a package, the package will be available (but not loaded) every time you open up R.

Once a package has been installed, you can load a package using the library() function. This is like launching an app on your phone. Likewise, if you were to run the code library(packagename), you will load all the functions in the package called ‘packagename’ and they will be available to you for the rest of your R session. However, the next time you start R, you will need to run the library(packagename) function again if you want access to those functions again.

A package we will use frequently is called ‘tidyverse’. ‘tidyverse’ is actually a group of packages that are useful for cleaning and organising data.frames. Install and load ‘tidyverse’ using the following commands. When installing a package, you may be asked to select a CRAN. This is the repository packages will be downloaded from. Select a server in the UK. Remember, you only need to install the ‘tidyverse’ package onto your computer once, but you will need to load it every time you start a new R session.

install.packages("tidyverse")   #This line installs tidyverse onto your computer

library(tidyverse)              #This line loads tidyverse for this session

The Working Directory

Often in R, you will need to import files saved on your computer, such as data sets. When analysing data in R, you usually want to have all of your scripts and data files in one folder of your computer. This folder is known as the working directory. It is best practice for different projects to be saved in different folders, and therefore each has a separate working directory.

To change your working directory, from the drop-down menus click on:

Sessions >>> Set Working Directory >>> Choose Directory…

Then select the desired folder.

Alternatively, you can use the setwd() function within a script. Just note that if you change computers, the file directory path will most likely be different.

Your working directory will be displayed in the bottom right window or RStudio when you click on the ‘Files’ tab.

Importing Data

Data can be saved as many different file types on your computer. These different file types are usually distinguished by the three letter extension following a period at the end of the file name. Here are some examples of common data file types and the functions you would use to read them in or write them out.

Extension	File Type	package	import
.csv	comma separated value	tidyverse	`read_csv()`
.xls, .xlsx	Excel file	readxl	`read_excel()`
.sav	SPSS data file	foreign	`read.spss()`

In general, I would suggest using a .csv file. This is advantageous because it can be read by many programs and is not tied to a specific program (like a SPSS or excel file), which future-proofs your data. Most programs, such as SPSS and excel, can also read .csv files. Regardless of which file type you are importing, R is expecting the data to be in a certain format. Namely, each variable should be in a separate column, and the variable names should be in the first row. If your data is not in this exact format (e.g., if there is any blank space in your data file), then R may not read it properly. You may need to edit your data file manually to make sure it matches this format (there are ways you can do it in R, but for beginners, it is generally easier to do this bit manually). You can save a data set to your computer in R using the write_csv() function.

Note, you can also read and write .csv file using base R functions read.csv() and write.csv() respectively; however, these functions have some default settings that can cause headaches in the future, so best to avoid these. Also note, the read_csv() function will output some red text that looks like an error message, but this is just R telling you how it interpreted all the variables, and usually means everything is okay.

Remember to download the data for this week’s demonstration and put it in your working directory before running the code below. Note that the class data set is already in the correct format.

#Remember to load the tidyverse library if you haven't already.
#The exact directory the file is in may differ depending on where the data file is on your computer.

data <- read_csv("data_2023.csv")

Once data is loaded, you can view the data.frame by either clicking on the data.frame icon in the work space, or using the View() function in the console. This will open a tab in the top left window, and clicking on this will show you the data.frame. This can be handy to make sure your data has loaded correctly, or double-checking whether functions used to clean your data has worked as intended.

Calculating Descriptive Statistics

In the lecture series, we covered measures of central tendency and dispersion. In particular, important statistics that you will need to calculate often are the mean and the standard deviation of a continuous variable. Thankfully, there are simple functions in R that can calculate these for you. In both cases, the first argument of the function accepts a numeric vector.

In the following examples, we will calculate the mean and standard deviation for the following numeric vectors:

prime.numbers <- c(1,2,3,5,7,11,13,17,19,53)

prime.numbers.na <- c(1,NA,3,5,7,NA,17,NA,53)

Calculating the Mean

The function that calculates the mean in R is called mean(). The first argument for this function accepts a numeric vector, which is the list of numbers you want to calculate the mean of.

So to calculate the mean for the prime.numbers vector above, we can use the following code:

mean(prime.numbers)

## [1] 13.1

So, the mean for the numbers in prime.numbers is 13.10.

This seems simple enough; however, if we try the same code to compute the mean for the vector prime.numbers.na, an error message is returned. This is because prime.numbers.na has missing values. R considers any value coded as NA as a missing value. Missing values can be due to many reasons, sometimes they are meaningful, but other times they can be ignored. To ignore missing values in the mean() function, we can set the na.rm argument to TRUE:

mean(prime.numbers.na, na.rm = TRUE)

## [1] 14.33333

Calculating the Standard Deviation

The Standard Deviation of a vector can be calculated in the exact same way as the mean, except we use the sd() function.

So to calculate the standard deviation for the prime.numbers vector, we use the code:

sd(prime.numbers)

## [1] 15.35108

So the standard deviation of prime.numbers is 15.35.

Similarly, the sd() function doesn’t deal well with missing values. So to calculate the standard deviation of prime.numbers.na, we use:

sd(prime.numbers.na, na.rm = TRUE)

## [1] 19.74504

Other Descriptive Statistic Functions

Here are some other functions that may come in handy… why not try some of them out? There are many more functions that exist in R. If you ever need to calculate a certain descriptive statistic for a variable, there is probably a function for it, and you can discover what it is with a bit of Google-ing.

Function	File Type
`max()`	Returns the largest value in the vector.
`min()`	Returns the smallest value in the vector.
`sum()`	Adds all the numbers in the vector together.
`is.na()`	Returns a logical vector telling you whether an element is missing.

table() Function

Another useful function is the table() function. This function tells you the frequency that each value appears for a vector. This can be handy if you need to quickly see the separate values that exists for a variable, or quickly count how often a value appears (e.g., if you need to calculate which value is the mode).

Here is an example of using the table() function with a vector:

catagories <- c("CatA","CatB","CatA","CatC","CatB","CatA")

table(catagories)

## catagories
## CatA CatB CatC 
##    3    2    1

So for instance, above, we can quickly see that there are three separate values in the vector catagories, and the one that appears most frequently (i.e., is the mode) is CatA.

We can also use the table() function for variables in data.frames. An example of this is below using the class data and the question about favourite Australian animals. How to read the code below is that we use the $ symbol to index which variable we want to look at in the data.frame called data. See the extra materials for more information on indexing.

table(data$aus.animal)

## 
##  echidna kangaroo    koala platypus   wombat 
##       28       24       27       21       20

So above, we see that there are five separate values (if we ignore missing data), and the most frequent response was koala.

Tidyverse Functions

The tidyverse package provides handy functions for data cleaning and manipulation. Remember, these functions work like all other functions: they take a number of arguments, such as a data.frame and instructions, then gives you an output that can be saved as an object, such as another data.frame. In this week’s demonstration, we will cover one function that you can use to calculate descriptive statistics; however, there are many more tidyverse functions. We will cover a few more next week, but for a full list, see the tidyverse cheatsheets, or view the help documentation using help().

All tidyverse functions to do with data cleaning follow the same structure:

function_name(data.frame,instructions)

where the first argument is always the data.frame you wish to perform the function on, and the remaining arguments are instructions on how you wish to perform that function.

summarise()

Functions like mean() and sd() are great when you want to calculate descriptive statistics from a vector, but more often than not, you will need to get these values from a variable in a data set. One way to do this is use the summarise() function from the tidyverse package.

So how does the summarise() function work? This function takes multiple arguments. The first argument of the function is the data.frame that has the variables you’re interested in. The remaining arguments tells R which descriptive statistics you would like it to calculate (i.e., multiple descriptive statistics can be calculated at once). You can tell summarise() which stats you want it to calculate using the same functions we covered above (e.g., mean(),sd(), etc.). In return, summarise() will return another data.frame with the descriptive statistics you’ve asked for. Therefore, for each stat that you calculate, you will need to provide a new variable name. For each descriptive stat that you want to calculate using summarise(), you will need to provide an additional argument that takes the following form:

variable_name = function(variable)

This may sound confusing, but it helps to see it in action. Below is the code to calculate the mean and standard deviation of the variable stats_exp in the data.frame called data.

summarise(data,
          stats_exp.mean = mean(stats.exp, na.rm = TRUE),
          stats_exp.sd = sd(stats.exp, na.rm = TRUE))

## # A tibble: 1 × 2
##   stats_exp.mean stats_exp.sd
##            <dbl>        <dbl>
## 1           5.05         2.61

A couple of things to note. First, I have broken the above code across several lines. This is just to make it easier to read (remember R ignores white space inside an incomplete command). Second, it doesn’t matter what you name the new variable (but ideally you want a label that is helpful).

As mentioned, you are not limited in the number of stats you can compute using the summarise() function, so by expanding the code above, we can calculate the means and standard deviations of multiple variables:

summarise(data,
          stats_exp.mean = mean(stats.exp, na.rm = TRUE),
          stats_exp.sd = sd(stats.exp, na.rm = TRUE),
          stats_anx.mean = mean(stats.anx,na.rm = TRUE),
          stats_anx.sd = sd(stats.anx,na.rm = TRUE))

## # A tibble: 1 × 4
##   stats_exp.mean stats_exp.sd stats_anx.mean stats_anx.sd
##            <dbl>        <dbl>          <dbl>        <dbl>
## 1           5.05         2.61           5.02         2.60

Note: An annoying thing about the summarise() function is that sometimes it will not show results to two-decimal places (which is the requirement for APA format). To see all the decimal places, you can View() the data.frame produced by the summarise() function.

HPSP131 - Workbook 2 - Data Skills: Data Frames and Descriptive Statistics

Objectives

Class Data

Exercises