# assign the current year to a variable
current_year <- 2021

# print the variable we created
# (it should display below the chunk, or in the console pane)
current_year

[1] 2021

# do a calculation to create a new variable from an existing one
next_year <- current_year + 1

Each instruction we give R produces a result.

By default, these results are shown below the code chunk.

Sometimes, though, we’d like to save the results. Perhaps we want to use them in another calculation later?

To do this we can create a variable.

A variable is just a container. We can store things in it: the results of simple calculations, datasets, tables, plots, or even statistical models.

To make variables we use the assignment operator, which looks like this <-.

It looks like an arrow that points to the left, but it’s made up of an left angle bracket (<) and a hyphen (-), placed next to each other.

The arrow is a reminder that the value on the right hand side will be assigned (stored) in the variable named on the left hand side.

For example, we can write this:

# assign the current year to a variable
current_year <- 2021

And we now have a variable called current_year which contains the number 2021.

The simplest way to check what a variable contains is to write it’s name, and then run that line of code:

# print the variable we created to the console window
current_year

[1] 2021

You might wonder where these variables get saved. In most cases, variables you create are stored in what’s called the Global Environment. You can see them in the Environment pane in RStudio.

The names of variables are shown in the column on the left, and their values in the column on the right.

Once stored, we can use variables as the input to new calculations.

For example, in this example we are adding 1 to the current year and storing the result in another variable called next_year:

# do a calculation to create a new variable from an existing one
next_year <- current_year + 1

We often need to link a few commands together which modify data before analysing it.

For example, if we’re working with a big dataset we might only want analyse part of the data. We could do this in stages by selecting only the columns we want to analyse, filtering out any rows we don’t want to analyse, and then calculating some descriptive statistics for the data that’s left.

One way to do this would be to use variables to save the results of each stage, but this would produce lots of variables which can get confusing.

A different approach is to use what’s known as a ‘pipe’ — it’s another way to link together multiple instructions.

The pipe sends data from one piece of code to another.

It looks like this %>%.

Press Ctrl + Shift + M (Windows/Linux) or ⌘ + Shift + M (Mac) to add a pipe.

In session 1, you used the following code to “pipe” the fuel dataset into head(), which shows just the first few rows:

fuel %>% head()

You can think of your data as flowing along lengths of pipe, joined by functions which do things to the data, step by step, until the result you want plops out at the end.

Each %>% should be read as the word “then”, e.g. “pipe the fuel dataset, then head() it”.

The > in the pipe function reminds you of the direction in which your data is flowing (it only works left to right).

It’s important to know that the pipe doesn’t store the results of these steps.

Sometimes that’s OK. In our first example we just wanted to look at the first few rows of the fuel data.

But, you will usually want to save the result of a pipeline in a new variable.
For example, if we wanted to save the first few rows of the fuel data to a new variable we would write:

fuel_head <- fuel %>% head()

Here we combine assignment with a pipeline.

Remember that it is the final result of the commands on the right hand side of the <- that are assigned to the variable.

The result of the pipeline (a data.frame containing the first few rows of fuel) is saved to a new variable called fuel_head.

You can explore your variables using the Environment pane. A data.frame will have an icon that looks like a spreadsheet. If you click on the icon, the data.frame is displayed in a new tab in the Source pane.

This tab shows you the same information as printing the data.frame, such as the number of rows and columns, but it also provides tools for exploring the data interactively.

• The arrows next to the column names allow you to arrange the rows in ascending or descending order based on the column values.
• The Filter button allows you to specify a value for one or more columns to filter out non-matching rows. For example, we could display just cars with 4 gears. Click the button again to turn off the filter.

Some datasets are very large. We often want to work with a subset of the data, and filter() makes this possible.

library(psydata)

development %>%
  filter(country == "Kenya")

development %>%
  filter(country=="kenya")

development %>%
  filter(year > 2000)

development %>%
  filter(country == "Kenya") %>%
  filter(year > 2000)

development.europe <- development %>%
  filter(continent == "Europe") %>%
  filter(year > 1980)

development.europe %>%
    ggplot(aes(gdp_per_capita, life_expectancy)) +
  geom_point()

Patterns within a dataset are often easier to see after the data is summarised.

Summarising data means reducing lots of numbers to a smaller number.

For example, the mean is a summary which tells us about the central tendency.

To summarise data in R, we use summarise(), with a “summary function” which reduces some data values.

For example, the mean() summary function calculates the mean of some data values, in this case the mpg column:

fuel %>%
  summarise(mean_mpg = mean(mpg))

The result is a data.frame with a single column named mean_mpg (mean_mpg = defined the column name).

If you don’t assign the result of the summary function to a column name, it is named after the summary function:

fuel %>%
  summarise(mean(mpg))

You should normally specify a column name, because columns named after summary functions are awkward to process later in a pipeline.

The mean is just one of many summary functions.

We could also summarise mpg using a different measure of central tendency, the median.

In this case we would use the median() summary function:

fuel %>%
  summarise(median_mpg = median(mpg))

Another common summary is the standard deviation, which tells us how far, on average, data values are from the mean.

We can calculate the standard deviation using the sd() summary function:

fuel %>%
  summarise(sd_mpg = sd(mpg))

R only allows certain characters for column (and variable) names.

Errors caused by invalid characters can be confusing, but they’re easy to avoid if you follow these simple rules:

1. Only use lower case letters from the alphabet (a-z)
2. Use underscores _ instead of spaces

You can also use summarise() with more than one summary function.

Seperate each summary function with a comma:

fuel_summary <- fuel %>%
  summarise(m = mean(mpg), sd = sd(mpg))

Remember, the out from summarise() (in this case fuel_summary) is a data.frame that you could do more processing on in extra steps if needed.

development %>%
  filter(continent=="Asia") %>%
  summarise(asian_life_expectancy = mean(life_expectancy))

We said earlier that R is a bit like an obedient robot; it will do exactly what you tell it to do.

This means that you need to be very precise when writing R code.

One of the key skills to develop is your ability to spot, and correct errors which will prevent your code from doing what you want it to.

It’s natural to make one or two mistakes, especially when you’re first learning to use R. This video gives you some tips for avoiding and correcting errors in your R code.

The more you practice, the less mistakes you will make and the easier you will find it to spot errors which creep into your code.

R Studio has some features which can help you spot errors.

Here’s a chunk of code with various errors which we’ll correct one by one.

The first errors are in this line:

liibrary(todyverse)

library(psydata