LIFE 4138: R Workshop 2

Welcome to the 2nd R workshop of LIFE4138!

Last time, we learned a bit about the basics and structure of the R language, using base R. This time, it’s a little bit different. We’ll think about the different coding philosophies of R coding (there are many many many ways to approach R), and today I’ll guide you through a little bit of what is known as the tidyr philosophy. This is an arguably more advanced way to handle and explore your data, and then we’ll get some hands on experience of a different method of visualising data than last time, by using the ggplot2 package.

Right. Our main aim for today is to give you a little bit more insight into how R works, and how we can approach it. Don’t worry if you still don’t feel like you’ve got the basics absolutely nailed down, this is something that will come in time, with continued practice. Remember you can always look back at last session if you’re struggling, but now you’ve got a grounding of the basics, we can begin to build on it.

Keep in mind the language analogy. If you were learning Spanish, you’d appreciate that you have to keep practicing. You’d also realise pretty rapidly that there are often multiple ways to achieve the same result - the same is true for R. For any outcome, there are multiple ways to get there, and the only way to establish yourself as a proficient R (or Python, or unix, or C++, or any other language) user is to get stuck in and try things out!

R philosophies

There are many many ways that we can approach our coding in R. The original way, baseR, is what we covered in the last session. It was originally built on vector-based data, way back when R was first developed in the early 90s.

Another common approach to using R is a method known as tidyR, which utilises a selection of packages called the tidyverse. Each of the packages within the tidyverse are built with the same underlying ethos, which is the ability to make R code more readable and reproducible. The focus of data handling in the tidyverse is the data.frame object as an entire entity, rather than the vectors within.

There are several other popular R philosophies (for e.g. the data.table philosophy), but we wont delve into those here, we’ll stick to baseR and the tidyverse.

It’s worth knowing that you may well come across some rather strong opinions about these two coding methods, particularly on twitter. With some quick searching of the term “tidyverse”, you can quite quickly find some very heated debates! In the interest of balance, I’ll suggest that there are advantages and disadvantages to both approaches, and their applicability or suitability varies massively with the context of what it is that you’re trying to achieve.

In my opinion, it’s better to be bilingual. Use what works for you, when it works for you. I tend to use a bit of a mishmash of both approaches, but then I’m not overly opinionated on the subject. Do what works. Tidyverse can help to make things a little clearer, but in some cases it’s overkill, and baseR is actually simpler to use.

What is the tidyverse?

The tidyverse is a diverse set of packages and tools, which include popular packages such as dplyr, ggplot2, readr, and purrr. Several of these packages you might use without ever explicitly calling them, because of the nature of the way that the tidyverse is installed. The main ones that we’ll focus on here are dplyr and ggplot2. ggplot2, as the name might suggest, is a package explicitly designed to rethink the way that R handles plotting and data visualisation. We’ll talk more about that later though.

dplyr

dplyr is a really useful package for data wrangling and manipulation. It is invaluable when you are trying to get your data into a useable format, or get a quick summary to help you understand your data a little better. It is particularly useful for filtering your dataset. dplyr allows you to extract information to get your data into shape for downstream analysis.

The principle of data wrangling sounds tedious, but it is a crucially important part of bioinformatics and data science. dplyr is explicitly designed to handle data wrangling in R, and uses a variety of tools and functions to make this easy and accessible. As an analogy, if like me, your desk is messy and chaotic, I often find that tidying it up is a great way to help me to focus my mind on what it is I’m meant to be getting on with, rather than just staring at the mess and playing with the random bit of bluetac I’ve found. The same principle can be applied to your data. If you have a messy dataset with loads of variabes and nonsense in, it can become difficult to focus. Filtering out the stuff you don’t need and tidying it up is a vital first step in any analysis.

To get to grips with this, we’re going to use a really popular dataset that’s integrated into dplyr - the starwars dataset. The likelihood of you being a starwars superfan with an encyclopaedic knowledge of the heights and weights of characters from within the starwars universe is low, so it provides an excellent example of how, by using dplyr, you can get to know and understand a dataset.

Let’s get cracking then.

First things first, we need to install and load the packages we need. There are several ways of doing this, you can either install and load the entire collection of tidyverse packages, or we can just install the ones that we’ll need here:

install.packages("tidyverse")
library(tidyverse)

# or

install.packages("dplyr")
install.packages("ggplot2")
library(dplyr)
library(ggplot2)

Now, we can load the starwars dataset into our R session:

data(starwars)

You might notice that the starwars data displays as a tibble rather than the typical data.frame. A tibble is very similar to a data.frame, but with some bonus features. These are not generally immediately apparent (or particularly important in this context). A tibble is essentially an updated data.frame, and is a very neat tidyverse add-on. At first glance, it’s perhaps obvious that the display is a little nicer than we’re used to. Three main differences that you may notice:

• Shows only the first 10 lines - data.frame prints the entire contents - this essentially calls head() on the data.
• Also only displays the first few columns - the rest of the information such as the columns not shown is listed below the tibble output.
• There is information on how things are coded. Here we can see that the name is coded as a character input (which we might expect). Height is an integer, which is just a whole number with no decimal places (or, a discrete numeric). Mass is what is known in R as a double, or dbl - this essentially means it’s a floating point number with any potential value from -Inf to Inf.

We can use tibbles in the same way that we might use a data.frame - for e.g.:

starwars$name

displays the names of all of the characters in the tibble, just as it would in a data.frame format.

The pipe operator %>%

Before we go any further, it’s important to introduce the pipe operator to you. The pipe operator is a really useful bit of kit for coding in R, and it comes from the package magrittr (although the magrittr library is automatically loaded alongside dplyr so don’t worry about installing it!). The reason the pipe-containing package is called magrittr is because of a famous Belgian surrealist artist, who painted the famous “The Treachery of Images”, seen below:

The text, Ceci n’est pas une pipe is French for “this is not a pipe”.

The pipe function, coded as %>% allows you to “pipe” data from one command or function, directly to another. It works in a very similar way to unix pipes, and allows you to chain together functions in a single code block, allowing for more readable code. You rarely, if ever, have to use pipe operators in your code, but we’ll use them lots here to demonstrate their usefulness. I find pipes make for easier coding, as you can break down complex commands into their consituent parts, rather than wrestling with nested functions with a million brackets. Piping helps you to take a simple command, and build up the complexity of it slowly and logically, iteratively adding bits and sense-checking as you go, before you end up with a complex but readable and easily reproducible bit of code.

Let’s demonstrate the usefulness of a pipe alone, before we combine it with dplyr. Say we wanted to work out the length of the name column in the starwars dataset.

We’ll first demonstrate without the pipe operator, and then with it.

length(starwars$name)

[1] 87

starwars$name %>%
  length()

[1] 87

These two bits of code give us the same result (87!) - here, where the code is relatively straightforward and focussing around only a single function, it is perhaps easier to use the baseR version. When we get to more complicated stuff, the usefulness of pipes will be much more apparent. Essentially what the second bit of code is saying is take the name column from within the starwars dataset, and pop it inside the length function.

Piping and dplyr

The select() function

Piping is great for data manipulation, particularly when combined with the tools in dplyr. Say you want to select a column from a dataset. We can of course do this using our previous method of the $ operator, or, we can use the select() function from `dplyr.

starwars$name

starwars %>%
  select(name)

Here, the select() function perhaps makes it more obvious what the code means, particularly for those of you not used to reading R. You also end up with slightly different outputs, in that the tidyverse solution gives you a tibble output.

But, what if we want to select multiple columns in one go? In baseR, we would have to use our vector-based indexing strategies (the square brackets!), with the c() function. It’s much simplier in the tidyR solution:

# The baseR solution:
starwars[ ,c("name","homeworld")]

# Tidyverse:
starwars %>%
  select(name, homeworld)

Note that we do not use the “” in the select() function, because we’ve already told R that we are looking inside the starwars dataset, by piping it to the function. In the baseR solution, we have to use them otherwise R will look for objects first.

The select() function is a really quick and super powerful way of subsetting data. There are also several helper arguments that you can use inside of select() in order to customise how you want to filter. We will have a look at two of them below, but you can have a look at the rest by using the help function on the select command ?select.

First, we can use the helper function contains() to select only the columns that contain a certain character. Let’s try and use the tidyverse to select only columns which have an underscore (“_“) in:

Notice that this time, we used quotation marks as we are asking R to pattern match a bit of a string. We end up with the above tibble - the columns all contain an underscore in their names!

We can also use the starts_with() helper function. This time, we’ll select all the columns whos name start with a lower-case s:

Here, we end up with columns “skin_colour”, “sex”, “species”, and “starships” - all of which start with a lowercase s - so our code works!

The select() function is versatile - we can also use it to select all columns except name and homeworld, by editing the code we used earlier - recall we used starwars %>% select(name, homeworld) - we can just add - symbols in front of the column names we want to remove…

We can scroll through the resulting tibble and see that all columns except name and homeworld are present!

The filter() function

Okay, now we’ve learned how to select columns - how do we filter out rows? The language differs slightly (and so do the functions! when we’re discussing handling rows and columns:

We always select columns, and filter rows

In baseR, we use indexes to remove things. dplyr functions in a similar way, but is optimised for readability. It still inherently functions on the logical `TRUE/FALSE operators, but in a slightly different way. Let’s have a look at an example to better explain what I’m talking about. If we wanted to select all of the humans in our dataset, in baseR, we’d first have to return a series of logical operators, and then work out where to put them in our indexing system. In tidyR, we simply pipe to the filter() function:

# BaseR solution:
starwars$species == "Human" # This is the logical statement producing bit of code, that needs to go in the [] index system somewhere...
starwars[starwars$species == "Human", ] # Don't forget the comma to tell R we are only looking in rows!

# Tidyverse solution:
starwars %>%
  filter(species == "Human")

The particularly discerning will have noticed that these solutions provide us with two slightly different outcomes - the first gives us a tibble with dimensions 39x14, and the tidyverse solution gives us a tibble which is only 35x14. This difference is to do with the way the select() function handles NA values - it automatically removes them, whereas the baseR solution retains them in the output. In order to get rid of them, we need to add another function to our base solution - the which() function. By wrapping our filtering process in which(), we are telling R to remove any characters for which the species is a NA value:

starwars[which(starwars$species == "Human"), ]

This is where the difference between base and tidyR really becomes apparent - as an R novice, the base solution is difficult to interpret - it’s certainly not immediately obvious what is going on!

Right then - we’ve learned how to filter a dataset to show us only the results which contain a string value in a single column - what if we want to filter for more than one thing?! What if we want all humans which were born on Tatooine? We can just add another argument to our filter() function using a comma:

We can establish fairly quickly using the tidyverse approach that there are 8 humans in the starwars universe who were born on Tatooine.

Combining functions

So, we’ve estblished that you can select columns and filter rows - we can also combine these to create an even more powerful data wrangling tool! We can pull out the variables that we’re interested in, which is a key part of the tidyverse. It’s important here to note however that we are doing this process to better understand our data, not to just remove bits of it that we don’t want!

Now, let’s combine the select() and filter() commands using our pipe operator to give us a dataset that contains only the name, height, and birth year of our human characters:

starwars %>%
  filter(species == "Human") %>%
  select(name, height, birth_year)

Remember the differences in when you need to use quotations!

That was a really straightforward and easy to read way of filtering our dataset to contain only the information that we want. We can perform the same function in BaseR by filling in both sides of our square brackets to give a set of information about exactly what rows and columns we want to keep, but it is much clunkier and less user-friendly:

Using dplyr to get summaries of data

We can use the filter() and select() functions to summarise our data and give us some information about it. Summarising data is an important and useful tool - we might want to count the number of observations in a group, or get a mean value of subsets for example. There are a set of summary functions that are very useful for this - we’ll hav a look at tally(), group_by() and summmarise() below - they allow you to create a new tibble for plotting out output as a summary dataset.

Counting by groups

First, let’s learn to count within groups - perhaps we want to count how many of each species there are in our starwars data. We can do this by using the group_by() and tally() functions - lets see how they work:

starwars %>%
  group_by(species)

When you run the above, you end up with this tibble output. You can see at the top next to the dimensions that we have 38 different species in our dataset, but this isn’t obvious from looking at just the data. Let’s use the tally() function to count them up:

starwars %>%
  group_by(species) %>%
  tally()

Tally literally counts the number of occurrences within a single group, and produces a new tibble with a new count column, “n”. We can see the species names, and see that we’ve got 6 Droids and 3 Gungans, and 1 of everything else in the display. If we want more than 10 rows, we can pipe the code to the print() function, and provide how many rows we want in the argument n = within the function. If you want R to print all the data without having to check how many rows there are, you can ask it to print infinite rows with n = Inf:

starwars %>%
  group_by(species) %>%
  tally() %>%
  print(n = Inf)

Okay - but what if we want R to give us some more complex information? What if we want to know the counts of the genders within the species too? We can iteratively make our code more complicated to achieve these things - in this case, we just need to add another argument to the group_by() function:

starwars %>%
  group_by(species, gender) %>%
  tally() %>%
  print(n = Inf)

This technique is useful for counting bits of information, as well as plotting. Maybe you could envision a situation where you would want to plot the results of genders separately.

We can get more detailed still - we take take height and mass for example, and summarise it. This is similar to what we’ve just done, but slightly more complex - let’s work out the average height for each species. Here, we will introduce the summarise() function into our code pipeline.

starwars %>%
  group_by(species) %>%
  summarise(mean_height = mean(height, na.rm = TRUE))

The summarise command is made up of a series of components here:

• First, mean_height is creating a new column, called “mean_height”
• We are then using an = to tell R what to populate that column with
• After the =, we use the mean() function, with two arguments. The first is telling R what we want to work out the mean of (in this case, height), and the second is the na.rm = TRUE argument - recall from last session that lots of functions can’t cope with missing data, which overrides the rest of the data to give an NA output.

We are essentially asking R to look within each species, and return the mean values for height, removing any NA values as it goes.

Now, lets run the same code but add an extra column for mass - remember our coding style of starting small and adding bits on:

starwars %>%
  group_by(species) %>%
  summarise(mean_height = mean(height, na.rm = TRUE),
            mean_mass = mean(mass, na.rm = TRUE))

You can see here that even though we’ve got an na.rm argument, we still have a NaN in our dataset - this is because for whatever reason, it’s apparently impossible to gain data on the mass of a Chagrian!

As with all things in R, there is more than one tidyverse solution to the above problem, we can also use the vars() argument within the summarise_at() function, this is subtly different to the summarise() function, where we ask R to summarise multiple things at once using the same function:

starwars %>%
  group_by(species) %>%
  summarise_at(vars(height, mass), mean, na.rm = TRUE)

Hopefully, here we’ve demonstrated the use of the pipe mechanism in dplyr to build more complex commands which are readable and easy to follow the logic of. Remember to start simple, and build yourself up to the more complicated stuff, using the new “grammar” that you’ve learned to create complex code structures one step at a time. As a general rule, you shouldn’t use more than ten pipes in a single stretch - if you’re doing this, it’s probably best to resassign your object a new name part-way through the process and start from scratch with the new object.

ggplot2

Time for a bit of a tone change, to shift to a different way of exploring data within the tidyverse. Whist dplyr is great for exploring your data and getting to know it, data visualisation is a different approach.

The “gg” in ggplot2 stands for “the grammar of graphics”. The idea behind this package is that it is built to make you think about data vis in a slightly different way. The way that you use ggplot2 is different to plotting in baseR, and if you’re very familiar with base plots, it can seem difficult to get your head around, although it’s certainly worth persevering. However, if you are new to R, it’s a great way of learning how create graphics.

ggplot is extremely flexible, with lots of additional packages which you can install that integrate into it - the possibilities for graphical customisation are almost infinite. It’s a great way to create publication ready high quality plots quickly and easily - I know that I’ve used ggplot every single time I’ve written and published any science!

There are three key components to any graphics created in ggplot:

• A data.frame or tibble (where ggplot is getting the data to plot from)
• A co-ordinate based system of mappable variables - i.e. an x and y axis, allowing ggplot2 can map variables to it
• Layers of geometry, or geom, which plot your data.

This sounds quite complicated and abstract, but in reality it’s a simple concept - think of ggplot like a raster or vector based image processing/design software like photoshop or GIMP, where you iteratively add layers, building up to your final plot. Sound familiar? ggplot (and all the tidyverse packages) work on the same code-building philosophy as dplyr!

Before we begin, if you haven’t done so already, remember to load ggplot2 into your R environment:

install.packages("ggplot2")
library(ggplot2)

Scatter plots

The best way to learn is, as always, to have a go yourself. First, we’ll create a scatter plot! This is similar to the baseR plot(x, y) output, but infinitely more customisable. Let’s plot the relationship between height and mass of characters within the starwars universe.

# If you don't already have the starwars data loaded:
data(starwars)

We’ll build up those layers, starting with telling R what dataset we are using, with the ggplot() function, and slowly build up to a complete plot. Note that whilst the package is called ggplot2, the plotting function is just ggplot()

ggplot(starwars)

This generates us a nice blank grey square. It might not seem like a fabulous start, but we’ve managed to fulfull our first of the three necessary inputs - a dataframe.

Let’s build on this by adding the next part - employing a co-ordinate system for us to map our variables on to. We do this by using the aes() argument within the ggplot() function. Here, aes stands for aesthetics - which doesn’t mean what the plot looks like, but tells ggplot exactly what we want to map onto our graph:

ggplot(starwars, aes(x = height, y = mass))

Yay - we have our co-ordinate system and our axes in place ready to map the data onto. Note that in the aes() argument I have specified which is x and which is y, you do not need to do this. R automatically plots x and then y, so typing ggplot(starwars, aes(height, mass)) would yeild the same result.

Now, let’s add the points to the graph. We do this by adding a new layer to the plot, with one of the set of geom functions in ggplot - geom_point(). To add a new layer, we end the previous line of code with a +, which tells R that we weren’t finished with the last line:

ggplot(starwars, aes(x = height, y = mass))+
  geom_point()

You may see a warning that says R has removed 28 rows with missing values - these are just our NA values from the dataset, so you can ignore that for now.

Now, plotting our scatter plot of height and mass has shown us why we might want to plot our data - it seems that we have a single individual with a mass of around 1400 units, whereas everyone else is below about 200! If you know anything about the starwars universe you might be able to guess who this is… For everyone else - let’s see if we can work it out by going back to our dplyr skills that we’ve just learned, and add in a way to only display information about individuals with a mass of greater than 1000!

starwars %>%
  filter(mass > 1000) %>%
  select(name, species, mass)

If you know anything about starwars, perhaps unsurprisingly, our answer is Jabba the Hutt!

Anyway, back to ggplot.

Histograms

Sometimes, you might want to plot the distribution of your data. This is useful for both identifying outliers, and also for seeing what our data look like. In lots of statistical tests, we make assumptions regarding the distribution of our data - often this assumption is that our data follow a normal distribution. We can create a histogram really quickly using ggplot and see if this is true!

We’ll start by building up our data as we did before, but we’ll go straight to adding the co-ordinate system:

ggplot(starwars, aes(mass))

You might have noticed that we only have one axis here - this is because we have only supplied R with a single aesthetic (the x aesthetic). The reason that we have done this, is because histograms plot a single variable against it’s count - we don’t know what that count is yet, ggplot will figure that out for us. Notice also that we can get an idea of the scale just by looking at the x axis, we can see here that our mass ranges from 0 to way above 1000 (which we now know is a direct result of Jabba the Hut!).

Let’s add the histogram geom.

ggplot(starwars, aes(mass))+
  geom_histogram()

We can see that, as in our scatterplot, most individuals are below about 250 units of mass, with a single individual way over 1000!

There are loads of different geoms available, and lots of online resources to check out - the ggplot manual is particularly useful! For now, let’s just have a look at one more, the boxplot. Boxplots are an incredibly useful way of looking at distributions of data within groups, and working out whether particular groups from a single dataset differ from one another in a certain measurement. Let’s plot a boxplot that tells us about the mass of species from within the starwars universe:

ggplot(starwars, aes(x = species, y = mass))+
  geom_boxplot()

Ah. This isn’t a very nice plot. There’s far too much data, and it’s all very messy. We can’t see any of our species names, or really work out what’s going on at all - lets learn how to fix it…

Combining ggplot2 and dplyr

It’s time to combine our new plotting and data-wrangling skillsets! ggplot is a great way of showing data, but really the power of the tidyverse comes when you integrate the packages with one another. The combined philosophies of dplyr and ggplot2 can create us a much nicer plot. Because dplyr and ggplot2 were built together under the tidyverse umbrella, they integrate really smoothly with one another, and combining them is as simple as piping from a dplyr filter into a ggplot function. You can take a dataset you don’t know, and really get a handle on it by combining these tools. Let’s try here.

We’ll go back to our boxpot and use what we’ve learned with dplyr to create a much nicer boxplot that describes the mass of three different species (rather than all of them at once!). So, which species shall we use? In a dataset that contains lots of observations of a single individual of a species, I think it makes sense to select the three most abundant species. Remember how earlier we used the group_by() and the tally() functions to get R to count the number of individuals in each species?

starwars %>%
  group_by(species) %>%
  tally()

This is great, but it would be better if we could order it and see at a glance which species had the most individuals - we can do this with the arrange() function and the desc argument:

starwars %>%
  group_by(species) %>%
  tally() %>%
  arrange(desc(n))

desc(n) tells the arrange() function that we want to display our data in descending order of the number of individuals in each species.

We can see from the resulting tibble that we have 35 humans, 6 droids, our next highest is NA where species wasn’t recorded, so we’ll ignore that, and then 3 gungans. We’ll plot the mass of each of these three species! To do this, we will need to filter our data using dplyr. We can filter for mulitple matches using the OR operator | thus:

starwars %>%
  filter(species == "Human" | species == "Droid" | species == "Gungan")

When we run the code to sense check ourselves, it’s tricky to see if it’s worked in the way we wanted. We can get round this by piping to select so we can only see the relevant columns:

starwars %>%
  filter(species == "Human" | species == "Droid" | species == "Gungan") %>%
  select(name, species, mass)

Right, we still can’t see if we’ve got any Gungans in here. Let’s get around that by adding a tally to display a count of how many species are in our new selection - don’t forget the group_by() to tell tally what it needs to count!

starwars %>%
  filter(species == "Human" | species == "Droid" | species == "Gungan") %>%
  select(name, species, mass) %>%
  group_by(species) %>%
  tally()

Fabulous. It seems that we’ve got all of our data in check, and our code seems to be doing what we want it to! We can delete those final group_by() and tally() sense checks, and pipe straight to ggplot. We’ll just plot the aesthetics first to check if we’ve got the correct mapping and that only three species appear on the x axis. We don’t need to include the name of the data in our ggplot() command this time - R already knows what data we’re using from our piping

starwars %>%
  filter(species == "Human" | species == "Droid" | species == "Gungan") %>%
  select(name, species, mass) %>%
  ggplot(aes(x = species, y = mass))

Excellent. Now, let’s add the boxplot geom.

starwars %>%
  filter(species == "Human" | species == "Droid" | species == "Gungan") %>%
  select(name, species, mass) %>%
  ggplot(aes(x = species, y = mass))+
  geom_boxplot()

This is a much nicer and more successful boxplot than before! We can see that the mean mass of Droids tends to be much lower than Gungans and Humans, but their mass is more variable.

We have successfully combined ggplot and dplyr in a really useful and powerful way, that will make exploring data much quicker and easier.

Reshaping data

The starwars dataset is already in a nice format for plotting, and we haven’t needed to do anything with it to get it there. This won’t always be the case with real world data. Sorting this out is complicated, and it’s okay if you don’t fully grasp the following the first time round - you’ll get used to it by practicing and having a go with data in your own time.

Now, there are two main types of data:

• long data - many rows, but few columns. An individual has many rows, each with a different observation on it
• wide data - many columns, fewer rows. Each individual is a single row, with many columns of observations

Sometimes, it’s necessary to swap between these types of data so we can produce the plot that we want. The pivot_data functions allow us to do this. pivot_longer will convert a wide dataset into a long one, by reducing the number of columns and increasing the number of rows, converting columns into new rows, and pivot_wider does the opposite.

We’ll use the iris dataset to demonstrate. As a reminder, the iris dataset contains different measurements (petal length, petal width, sepal length, and sepal width) from multiple individuals of three different species of iris. If we view the data with head we can see that the data is in a wide format, where a row represents a single individual with columns of observations:

head(iris)

We want this dataset to be long, with multiple rows per individual, and only a single column of measurements. Let’s have a go at using pivot_longer() to achieve this. The first thing we have to consider, though, is that iris is a data.frame rather than a tibble. We can fix that by piping to as_tibble() before we reshape. We’ll also assign all of this to a new object, that we’ll call iris2.

iris2 <- iris %>%
  as_tibble() %>%
  pivot_longer(col = 1:4, names_to = "measure")

Let’s dissect that pivot_longer() function:

• the col = 1:4 argument tells the function that we want to convert these 4 columns into individual rows. We don’t include the fifth column, species, as this is an identifier rather than a measurement.
• the names_to = "measure" is simply creating a new column where we can store the original column headings.

Note that when we assign things, we don’t automatically get them as an output too - let’s call iris2 and see what it looks like:

Great. The data is now in a long format, rather than wide. We can plot it as a boxplot that tells us information about each species and measurement seperately. Let’s try it with what we currently know of ggplot:

ggplot(iris2, aes(x = Species, y = value))+
  geom_boxplot()

This plot has given us three different boxes on our plot - one per species. We’ve conflated all of the measurements together - this is simply because we haven’t told R that we want them separated! We can do this using a tool known as facet grids, which is essentially a fancy way of saying “splitting plots to pull out different measurements”. Let’s try adding a facet_grid() layer to our plot, and including the argument ~measure within it. Remember that a ~ denotes a relationship between things, so by calling facet_grid(~measure) we are asking R to plot the above, but separating the plots between measurement types. Lets have a go:

ggplot(iris2, aes(x = Species, y = value))+
  geom_boxplot()+
  facet_grid(~measure)

Great, so now we’ve managed to separate our measurements out into individual plots, and by doing this we can learn more about the data! We can see that the setosa species tends to be smaller than the other two generally, with the exception of it’s sepal width. Hopefully now you can see how reshaping your data in this way allows you to explore it differently, and get to know it a little better!

Saving plots

So now we’ve got our data plotted and ready to go, we might want to save it. Helpfully, there is an “export graph” button on the plot window that makes this nice and easy. Although there might be a situation where you’ve used R to automate the production of multiple plots, and you’d like to include a save function within the code itself. You can do this fairly simply with the ggsave() function, which basically does what it says on the tin.

You give the function a name and a file extension in the form of “my_plot.png” for example, and R will save it into your working directory. Try the following

ggsave(my_plot.png)

and you should see that R has saved your plot into your project folder. You can test this by navigating to your file tree in Rstudio and clicking on the newly saved plot to open it. Helpfully, R will interpret the .suffix as a file format, so you can change this at will - perhaps you want a .tiff or a .pdf file - just change the suffix and R will do this for you.

A note on dimensions - R will automatically export a plot with the dimensions of the plot window - you can either change that by manually adjusting these, or by hard-coding some dimensions into the ggsave() function - have a look at the ?ggsave help files to find out more!

Customisation

There are loads of ways to customise your R plots, that we don’t have time to discuss now, but a quick google will show you that there are endless possibilities - go away and have fun!

And finally…

So, we’ve learned a bit about the philosophies and approaches to using R, and looked at more advanced ways of handling data with dplyr. We’ve gained some hands-on experience with using ggplot2 to produce plots.