Welcome to R basics

≈ 10 min

R is a language and an environment for working with data: for calculations, statistics and graphs. This course starts from the very beginning, so you don’t need to have done any programming before.

R and RStudio

R is free, it runs on Windows, macOS and Linux, and it copes with far more data than a spreadsheet can. It comes with a wide range of statistical tests, thousands of add-on packages extend it further, and it can draw graphs that look exactly the way you want them to. That is why it is used so widely for analysing data and for drawing figures for publication. The price of all this is that R expects you to type commands rather than click on menus, which can feel daunting at first, so this course takes you through the basics one small step at a time.

RStudio is a program that makes R much easier to work with, and it is what most people use. On your own computer, you would install R first (from r-project.org) and then RStudio. Here, the RStudio tab of the workbench on the right is an imitation of RStudio made for teaching, and R itself runs inside your web browser, so there is nothing to install.

Finding your way around RStudio

RStudio’s window is divided into four panes, laid out like this. Until you open a file, the Source pane is folded away and the Console has the left-hand side to itself.

Sourcetop leftAn editor for scripts: files of R commands that you can run, save and come back to. It opens when you open or create a file.

Environmenttop rightThe objects in R’s memory, with their values. The History tab next to it lists the commands you have run.

Consolebottom leftWhere R runs your commands. You type a command after the prompt, >, press Enter, and R prints the answer underneath.

Files, Plots, Packages, Helpbottom rightYour files, the graphs you draw, the packages you have installed, and R’s help pages.

How this course works

Each chapter explains an idea, shows you some R, and then gives you an activity to do in the workbench. The instructions are on the left and the workbench is on the right; you can drag the divider between them to change their widths.
The steps of an activity tick themselves when R sees that you have done them, and they are then marked ✓ spotted. If a step hasn’t ticked when you know you have done it, you can tick it yourself.
Buttons such as type code into RStudio’s Console for you, and you then press Enter to run it. You will learn more by typing the code yourself, though, so use the buttons when you are stuck rather than all the time.
Questions with a Check button are marked straight away. Once you have had a go at a question, a Show answer button appears, so that you can compare your answer with ours.
Parts marked If you have time are extras, and they don’t count towards your certificate.
Your ticks and answers are saved in this web browser, on this computer. My answers, at the top of the page, downloads a copy of your answers.
The first time you open the course, R itself has to be downloaded into your browser (about 30 MB), so it may take a moment to start.

Your name, for your certificate

When you have finished the course, you can download a certificate with your name on it. Add your name now, with the button below or with the Your name button at the top right of the page. Type it exactly as you would like it to appear on your certificate, for example Ada Lovelace. Your name is only kept in this browser, and you can change it at any time.

AI tools and your data

The AI tab has an AI assistant that you can ask about R, if you have a key for an AI service. Anything you type into it is sent to an AI company, so never paste personal data or patient data into it, or into any other AI tool.

Get started

Add your name for your certificate:
Click in RStudio’s Console, at the bottom left of the workbench, type 1 + 1 and press Enter. R prints the answer, [1] 2, underneath.

R as a calculator

≈ 15 min

The simplest way to use R is as a calculator: you type a sum into the Console, press Enter, and R prints the answer straight away.

R understands the usual arithmetic operators:

Operator	What it does	Example	Answer
`+`	addition	`3 + 2`	5
`-`	subtraction	`10 - 4`	6
`*`	multiplication	`6 * 7`	42
`/`	division	`2 / 7`	0.2857143
`^`	raising to a power	`5 ^ 10`	9765625

Here is what the Console looks like after three of these sums:

> 3 + 2
[1] 5
> 2 / 7
[1] 0.2857143
> 5 ^ 10
[1] 9765625

The [1] in front of each answer is something you will see all the time. It means that the line starts with the first value of the answer, which will make more sense when you meet answers that contain many values, in the chapter on vectors. R shows answers to seven significant figures, but it keeps the full value in its memory, and uses that in any further calculations.

R works out powers first, then multiplication and division, and then addition and subtraction, just as you would on paper. Use round brackets to change the order: 2 + 3 * 4 is 14, but (2 + 3) * 4 is 20.

Spaces, unfinished commands and the ↑ key

R ignores the spaces between the parts of a command, so 3+2 and 3 + 2 do the same thing, but spaces make your code easier to read. If you press Enter before a command is finished, for example straight after 5 *, R shows a + instead of its usual prompt, to tell you that it is waiting for the rest of the command. Either type the rest of it, or press Esc to abandon it. In the Console, the ↑ key brings back the commands you ran before, so that you can change one and run it again.

Do some sums

Use R to calculate 31 × 78. (In R, the multiplication sign is *.)
Calculate 697 ÷ 41.
Work out 2 + 3 * 4, and then the same sum with brackets: (2 + 3) * 4.
Type 5 * and press Enter. When R shows its + prompt, type 2 and press Enter again to finish the command.

What is 31 × 78?

2418

And what is 697 ÷ 41?

What answer does R give for 10 - 2 * 3?

4 24 An error, because of the spaces

Keeping your commands in a script

Anything you type into the Console is run straight away, but it isn’t kept anywhere, apart from in the list of commands on the History tab. When you are doing real work you will want a record of your commands, so that you can run them again, correct them, or show someone else what you did. In RStudio you do this by writing your commands in a script: a plain text file of R commands, saved with the extension .R.

Start a script

Choose File ▸ New File ▸ R Script. (The first button on RStudio’s toolbar, with a green plus sign, has the same menu.) A new, empty script opens in the Source pane, above the Console.
Type # my first script on the first line of the script, and 2 ^ 8 on the second. With the cursor on the second line, press Ctrl+Enter (⌘+Enter on a Mac). RStudio sends the line to the Console and runs it.
Save the script with Ctrl+S (⌘+S on a Mac), and call it basics.R.

Console or script?

A line that starts with # is a comment. R ignores it, so you can use comments to leave notes for yourself. In this course you can type commands into either the Console or your script. The show me buttons put code into the Console, because that is the quickest way to try something out, but whenever you write something you want to keep, put it in your script and save it.

Keeping values in objects

≈ 15 min

Rather than typing the same values again and again, you can store a value in an object with a name, and then use the name instead of the value. Objects are often called variables.

To create an object, you use the assignment arrow, which is made of a less-than sign and a hyphen. The arrow points from the value to the name it will be stored under, and it can point either way:

10 -> x
y <- 20

Nothing is printed when you create an object, but it appears in the Environment pane, along with its value. To see the value in the Console, type the name of the object on its own. After that, you can use the name wherever you would have used the value, and you can store the result of a calculation as a new object:

> 10 -> x
> y <- 20
> x
[1] 10
> x + y
[1] 30
> x + y -> z
> z
[1] 30

If you assign a new value to a name that already exists, the old value is replaced, without any warning. You will also see code that uses = for assignment, as in x = 10. That works too, but <- is what most R users write, and it is what this course uses. In RStudio, Alt+- (Option+- on a Mac) types the arrow for you, with a space on either side.

Choosing names

R has a few rules about names:

A name can contain letters, numbers, dots (.) and underscores (_), but no spaces or other symbols.
It can’t start with a number: sample2 is fine, but 2sample isn’t.
Upper and lower case letters are different, so Weight and weight are two different objects.

Beyond the rules, a good name tells you what an object holds: weight is better than x, and gene_name is better than gn. Most people keep their names in lower case and separate the words with dots or underscores, as in gene.name or gene_name. Pick one style and stick to it.

Error: object not found

If you ask for an object that doesn’t exist, R tells you: Error: object 'Z' not found. The usual causes are a typing mistake, a capital letter where you meant a small one (or the other way round), and forgetting to run the line that creates the object. The Environment pane shows you exactly which objects exist.

Create some objects

Give x the value 39.
Give y the value 22.
Make z the value of x divided by y, using the objects rather than the numbers.
Display the value of z in the Console, and find x, y and z in the Environment pane.

What is the value of z, to two decimal places?

1.77 (R prints 1.772727)

Which of these names is not allowed in R?

2nd.sample sample_2 Sample.Two

You run x <- 5 and then x <- x + 1. What is the value of x now?

6 5 An error, because x can’t appear on both sides

Functions, text and help

≈ 25 min

Most of the work in R is done by functions. You give a function some values to work on, which are called its arguments, and it gives you back a result.

Calling a function

To use a function, you type its name followed by round brackets, with its arguments inside the brackets. For example, the function sqrt calculates square roots:

> sqrt(10)
[1] 3.162278

An argument can be a value, an object, or the result of another function. When one function is inside another, R works from the inside out: in log2(sqrt(16)), it first works out sqrt(16), which is 4, and then log2(4), which is 2. You can get the same answer in two steps instead, by storing the square root in an object and then giving the object to log2.

Text

Text in R always goes in quotes. You can use double quotes or single quotes, as long as you use the same kind at both ends:

scientist <- "Ada Lovelace"
first.name <- 'Ada'

The quotes tell R that you mean the text itself. Without them, R thinks that you mean an object with that name, so first.name <- Ada gives the error object 'Ada' not found. Be careful with code that has been copied from a word processor: R only understands straight quotes (" and '), not the curly ones (“ and ”) that word processors put in.

Two useful functions for text are nchar, which counts the characters in a piece of text, and substr, which extracts part of it, from a start position to a stop position. Spaces count as characters too:

> scientist <- "Ada Lovelace"
> nchar(scientist)
[1] 12
> substr(scientist, 5, 8)
[1] "Love"

Arguments by position and by name

Every argument of a function has a name. The arguments of substr are called x (the text), start and stop. If you give the arguments in the order the function expects, you don’t need to name them; if you do name them, you can give them in any order you like. These three commands all do exactly the same thing:

substr(scientist, 5, 8)
substr(x = scientist, start = 5, stop = 8)
substr(
  start = 5,
  stop = 8,
  x = scientist
)

The last one is spread over several lines. R allows that: it keeps reading until the brackets are closed. Naming your arguments makes your code easier to read, and it lets you give a function just the arguments you need, as you will see in the next chapter.

Getting help

Every function has a help page. Type ? followed by the name of the function, as in ?sqrt, and the page opens in the Help pane, at the bottom right. Help pages all follow the same pattern: Description says what the function does, Usage shows how to call it, with its arguments in order, Arguments explains each argument, Value describes what the function gives back, and Examples, at the end, has code that you can copy and run. In the Usage section, an argument written as name = value has a default: if you leave that argument out, R uses the value shown.

If you don’t know the name of the function you need, ?? searches all the help pages for a word or phrase. ??substring lists every help page that mentions substrings, and you can click on any of them to open it. Searching the web works well too, although “R” on its own isn’t much use as a search term. Add the name of the function or package you are asking about, as in R substr.

Use some functions

Calculate the square root of 2345, and then calculate the log2 of the result. You can do it in one command, with one function inside the other, or in two.
Put your own name into an object called my.name. Remember the quotes.
Use nchar to find out how many characters there are in your name.
Use substr to extract the first character of your name.
Open the help page for sqrt, and find the section called Examples.
Search the help pages with ??substring, and open one of the pages it finds.

What is the log2 of the square root of 2345? Give at least three decimal places.

5.597686 (from log2(sqrt(2345)))

You type my.name <- Ada, without quotes. What happens?

R reports Error: object 'Ada' not found my.name now holds the text Ada my.name is left empty

The help page for round shows round(x, digits = 0) under Usage. What does digits = 0 tell you?

If you leave out digits, R rounds to 0 decimal places, which means to a whole number You always have to give a value for digits digits can only ever be 0

Vectors

≈ 25 min

In R, everything is a vector: an ordered set of values that are all of the same type. Even a single number is a vector, with just one value in it.

Everything is a vector

When you typed x <- 39, you made a vector of length 1, whose first (and only) value is 39. This is why R prints [1] before an answer: the number in square brackets is the position, within the vector, of the first value on that line.

All the values in a vector must be of the same type. The types you will use most are:

Type	What it holds	Examples
numeric	numbers, with or without decimal places	`3`, `0.25`, `-1.5`
character	text, in quotes	`"WT"`, `"Ada"`
logical	TRUE or FALSE	`TRUE`, `FALSE`

There are others too, such as factors, for text values that come from a fixed set of categories (the genotypes in an experiment, say), and dates.

Making vectors with c()

The function c(), which stands for combine, puts values together into a vector:

simple.vector <- c(1, 2, 4, 6, 3)
some.names <- c("Ada", "Grace", "Alan", "Mary", "Rosalind")

Because a vector can only hold one type of value, R converts values when you mix types. Any number can be written as text, but most text can’t be turned into a number, so if you mix numbers with text, you get a vector of text:

> c(1, 2, 3, "fred")
[1] "1"    "2"    "3"    "fred"

The quotes in the output show that the numbers have become text, and you can no longer do arithmetic with them. Watch out for this when you read in data from files: a single word in a column of numbers turns the whole column into text.

Functions that make vectors

For a run of whole numbers, use the colon operator: 4:20 gives you every whole number from 4 to 20.

> 4:20
 [1]  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

seq() makes other sequences. Its arguments are from, to, by and length.out. None of them is required: you give it enough of them to describe the sequence you want.

> seq(from = 2, by = 3, to = 14)
[1]  2  5  8 11 14
> seq(from = 3, by = 10, to = 40)
[1]  3 13 23 33
> seq(from = 5, by = 3.6, length.out = 5)
[1]  5.0  8.6 12.2 15.8 19.4

rep() repeats values. With times it repeats the whole vector, and with each it repeats each value in turn:

> rep(c("dog", "cat"), times = 3)
[1] "dog" "cat" "dog" "cat" "dog" "cat"
> rep(c("dog", "cat"), each = 3)
[1] "dog" "dog" "dog" "cat" "cat" "cat"

Looking at long vectors

A long vector fills the Console, and the numbers in square brackets at the start of each line help you to find your way through it. To see just part of it, head() shows you the first six values and tail() the last six; both have an argument n for a different number, as in tail(number.series, n = 10). length() tells you how many values there are.

Make some vectors

Create a vector called some.numbers that contains the numbers 2, 5, 8, 12 and 16.
Use the colon operator to make a vector called number.range that contains the numbers 5 to 9.
Use seq() to make a vector of 100 values that starts at 2 and goes up by 3 each time, and store it in a new object called number.series.
Print number.series to see the whole of it, and then look at its first and last values with head() and tail().
Use rep() to make a vector of 100 values that contains 25 each of WT, KO1, KO2 and KO3, and store it in an object called genotypes.

What is the last value in number.series?

299. The series goes 2, 5, 8 and so on: 2 + 99 × 3 = 299.

What does c(1, 2, 3, "fred") give you?

A vector of text: "1" "2" "3" "fred" An error, because you can’t mix numbers and text The numbers 1, 2 and 3, with "fred" left out

Which of these commands gives you 1 3 5 7 9?

seq(from = 1, to = 9, by = 2) seq(from = 1, by = 2, length.out = 4) rep(1:9, each = 2)

Vectorised operations

≈ 20 min

When you do arithmetic with a vector, R does it to every value at once. This is called a vectorised operation, and it is what makes R so quick to work with: one short command can change thousands of values.

Compare these three commands:

> 2 + 3
[1] 5
> c(2, 4) + c(3, 5)
[1] 5 9
> simple.vector * 100
[1] 100 200 400 600 300

You don’t have to tell R to go through the values one at a time: it simply applies the operation to all of them. Three rules decide how the values of two vectors are matched up.

The rules

1. Values in the same position are matched. The first value of one vector goes with the first value of the other, the second with the second, and so on.

Vector 1345678910

Vector 21112131415161718

Result1416182022242628

3:10 + 11:18: each value is added to the value in the same position of the other vector.

2. A shorter vector is recycled. If one of the vectors is shorter, R goes back to its start and uses its values again, as many times as it needs to.

Vector 1345678910

Vector 21112131411121314

Result1416182018202224

3:10 + 11:14: the four values of the second vector are used twice (the paler ones are the second time round).

This is why simple.vector * 100 works: 100 is a vector with one value, which is recycled for every value of simple.vector.

3. If it doesn’t fit exactly, you get a warning. When the length of the longer vector isn’t a multiple of the length of the shorter one, R still recycles the shorter vector and gives you an answer, but it warns you, because this is usually a sign of a mistake.

Vector 1345678910

Vector 21112131112131112

Result1416181719212022

Warning message: In 3:10 + 11:13 : longer object length is not a multiple of shorter object length

3:10 + 11:13: the second vector runs out part of the way through its third time round.

A warning is not the same as an error. After an error, R stops and gives you nothing; after a warning, you do get an answer, but R is telling you that it may not be the one you wanted.

Functions work on whole vectors too

Many functions work in the same way. sqrt(), log2() and round() work on each value of a vector, and nchar() counts the characters in each piece of text:

> log2(c(2, 4, 8, 1024))
[1]  1  2  3 10
> nchar(some.names)
[1] 3 5 4 4 8

Other functions summarise a whole vector with a single value. Among the most useful are length(), sum(), mean(), median(), sd() (the standard deviation), min() and max().

Vectorised maths

Subtract number.range from some.numbers, using the - operator in the same way as you would for any other subtraction, and look at the result.
Multiply every value in number.series by 1000, and store the result in number.series, replacing the original values.
Run 3:10 + 11:13 to see the warning for yourself.
Work out the median of number.series.

What do you get when you subtract number.range from some.numbers?

-3 -1 1 4 7: 2 − 5, 5 − 6, 8 − 7, 12 − 8 and 16 − 9.

What is the last value of number.series now?

299000 (299 × 1000)

What does c(1, 2, 3, 4) * c(10, 100) give you?

10 200 30 400 10 200 3 4 An error, because the vectors are different lengths

If you have time Centring on the median

This part is optional: it doesn’t count towards your certificate.

Before comparing samples, people often centre their values on the median: they subtract the median from every value, so that the middle of the data sits at 0. Work out the median of number.series, subtract it from all of its values, and store the answer in a new object called centred. Then work out the mean and the standard deviation (sd()) of centred.

Centre the values

Make centred, the values of number.series centred on their median.

What are the mean and the standard deviation of the centred values? Compare the standard deviation with that of number.series itself.

The mean is 0 and the standard deviation is 87034.48, the same as the standard deviation of number.series. Moving every value by the same amount moves the middle of the data, but it doesn’t change how spread out the values are.

Comparing and selecting values

≈ 15 min

Comparisons are vectorised too. Comparing a vector with a value gives you a TRUE or a FALSE for every value, which you can use to count values or to pick them out.

Comparisons

R has six comparison operators:

Operator	Meaning
`==`	equal to (with two equals signs, because a single `=` is used for naming arguments)
`!=`	not equal to
`<` and `>`	less than, and greater than
`<=` and `>=`	less than or equal to, and greater than or equal to

Like arithmetic, comparisons are done for every value of a vector, and the answer has a TRUE or a FALSE for each value:

> some.numbers
[1]  2  5  8 12 16
> some.numbers > 6
[1] FALSE FALSE  TRUE  TRUE  TRUE
> some.names == "Mary"
[1] FALSE FALSE FALSE  TRUE FALSE

An answer like this is a logical vector. When you do arithmetic with TRUE and FALSE, R counts TRUE as 1 and FALSE as 0, so sum() tells you how many of the values passed the test:

> sum(some.numbers > 6)
[1] 3

Selecting values

Square brackets after the name of a vector select values from it. Inside the brackets you can give the positions of the values you want, or a logical vector that says, for each value, whether you want it:

Code	Gives you	Which is
`some.numbers[2]`	`5`	the second value
`some.numbers[2:4]`	`5 8 12`	the second to the fourth values
`some.numbers[c(1, 5)]`	`2 16`	the first and the fifth values
`some.numbers[-1]`	`5 8 12 16`	every value except the first
`some.numbers[some.numbers > 6]`	`8 12 16`	the values that are greater than 6

The last of these is worth reading slowly. some.numbers > 6 gives FALSE FALSE TRUE TRUE TRUE, and the square brackets keep the values for which the answer is TRUE. In the Tidyverse course you will use exactly the same tests to choose rows from a table of data.

Count and select

Find out which of the values in number.series are greater than 150000.
Now use sum() to count how many of them are greater than 150000.
Select the first ten values of number.series, using square brackets.
Count how many of the values in genotypes are not WT.

How many of the values in number.series are greater than 150000?

50, from sum(number.series > 150000).

What does some.numbers[some.numbers < 10] give you?

2 5 8 TRUE TRUE TRUE FALSE FALSE 3

Random numbers and a t-test

≈ 15 min

R can generate random numbers from many statistical distributions, and it has functions for all the common statistical tests. Testing numbers whose true mean you know is a good way to get a feel for how a test behaves.

rnorm() draws random numbers from a normal distribution. Its first argument, n, is how many numbers you want, and its other two arguments, mean and sd, set the mean and the standard deviation of the distribution. If you leave those two out, R uses a mean of 0 and a standard deviation of 1. There are similar functions for other distributions, such as runif() (uniform), rpois() (Poisson) and rbinom() (binomial).

t.test() carries out a t-test. Given one vector, it tests whether the mean of its values could be 0; given two, it tests whether their means could be the same. Here it is comparing two small sets of numbers:

> t.test(c(1, 5, 3), c(10, 15, 30))

	Welch Two Sample t-test

data:  c(1, 5, 3) and c(10, 15, 30)
t = -2.5058, df = 2.1475, p-value = 0.1206
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 -40.00292   9.33625
sample estimates:
mean of x mean of y 
  3.00000  18.33333

The line to look at first is the one with the p-value. This is the probability of getting a difference at least as big as the one in your data if there were really no difference at all. By convention, a p-value below 0.05 is called significant. Here it is 0.12, so although the means of the two sets look very different (3 and 18.3), there are too few values, and they are too variable, for the difference to be significant. R has functions for many other tests too, such as cor.test() for correlations and aov() for analysis of variance.

Random numbers are different every time

Each time you run rnorm() you get a different set of numbers, so your results won’t match anyone else’s, or even your own the next time you run the same command. When you need random numbers that you can reproduce, run set.seed() first, with any whole number you like: after set.seed(42), rnorm(3) always gives the same three numbers.

Test some random numbers

Use rnorm() to generate 20 numbers from a normal distribution with a mean of 0 and a standard deviation of 1 (the defaults), and store them in an object called normal.numbers.
Give normal.numbers to t.test() to test whether their mean is significantly different from 0, and find the p-value.
Replace normal.numbers with a new set of 20 numbers from a distribution with a mean of 1, using the mean argument of rnorm(). Then test them with t.test() again.

Write down the p-values of your two t-tests. Which of them was significant, and is that what you expected?

Your numbers will be different from anyone else’s, but usually the first p-value (true mean 0) is well above 0.05, so the test finds no significant difference from 0, and the second (true mean 1) is far below 0.05, which is significant. Both results are what you would expect, because the first set of numbers really did come from a distribution with a mean of 0, and the second from one with a mean of 1.

You test 20 numbers made by rnorm(20) and get a p-value of 0.03. What does that mean?

It is a false positive: even when there is no real difference, about one test in twenty gives a p-value below 0.05 rnorm() isn’t working properly The true mean of the distribution isn’t 0

If you have time How many values do you need?

This part is optional: it doesn’t count towards your certificate.

Make two vectors of values, one drawn from a normal distribution with a mean of 10 and a standard deviation of 2, and the other from a distribution with a mean of 10.1 and a standard deviation of 2. Then test them against each other:

first <- rnorm(100, mean = 10, sd = 2)
second <- rnorm(100, mean = 10.1, sd = 2)
t.test(first, second)

How many values do you need in each vector before the t-test can reliably tell that the two means are different? Try 1,000 values and then 10,000, and run each test several times.

How many values did you need?

With 100 or even 1,000 values in each vector, the test usually misses the difference. A difference of 0.1 is only a twentieth of the standard deviation, and you need around 6,300 values in each vector to detect it 80% of the time, and over 10,000 to detect it 95% of the time. Small differences need large samples.

Lists and data frames

≈ 20 min

Vectors are the building blocks of all the data in R. To hold data that is more complicated than a single set of values, R puts vectors together into lists and data frames.

Vectorone dimension, a single type

scores0.81.23.31.82.7

Listnamed vectors of any types and lengths

ratios0.81.23.31.82.7

counts100300200

Data frame or tibblenamed vectors of the same length, so the values form rows

mon0.80.60.20.80.6

tue0.90.70.30.81.0

wed0.80.50.30.90.9

passTFFTT

Vectors

A vector is a single set of values, all of the same type. You have already worked with plenty of them, and you have used functions such as mean() and sd() that summarise all the values of a vector at once.

> scores <- c(0.8, 1.2, 3.3, 1.8, 2.7)
> mean(scores)
[1] 1.96
> sd(scores)
[1] 1.035857

Lists

A list collects several vectors together into a single object. The vectors can be of different types and different lengths, and each has a name. You take a vector out of a list with $ followed by its name:

results <- list(
  ratios = c(0.8, 1.2, 3.3, 1.8, 2.7),
  counts = c(100, 300, 200)
)

> results$counts
[1] 100 300 200

Data frames

A data frame is a list whose vectors all have the same length. Because the vectors line up, a data frame has rows as well as columns, like a table in a spreadsheet: each column is a vector, with values of a single type, and each row holds one set of observations. Most of the data you analyse in R will be in data frames.

all.results <- data.frame(
  mon = c(0.8, 0.6, 0.2, 0.8, 0.6),
  tue = c(0.9, 0.7, 0.3, 0.8, 1.0),
  wed = c(0.8, 0.5, 0.3, 0.9, 0.9),
  pass = c(TRUE, FALSE, FALSE, TRUE, TRUE)
)

> all.results
  mon tue wed  pass
1 0.8 0.9 0.8  TRUE
2 0.6 0.7 0.5 FALSE
3 0.2 0.3 0.3 FALSE
4 0.8 0.8 0.9  TRUE
5 0.6 1.0 0.9  TRUE

$ works in the same way as it does for a list: all.results$mon is the mon column, as a vector, so mean(all.results$mon) is the mean of that column. head() shows the first rows, nrow() and ncol() count the rows and the columns, and str() summarises the structure of the data frame, with the type of each column and its first few values. The Environment pane lists data frames under Data, and clicking on one opens it in a viewer, as does View() (with a capital V).

Tibbles

A tibble is the tidyverse’s version of a data frame. It holds the same kind of data, but it is nicer to work with: when you print a tibble, it shows the type of each column and only the first ten rows, and it only shows as many columns as fit across the Console. You will use tibbles all through the Tidyverse course.

Lists and data frames

Create the list results, as above.
Calculate the mean of the counts in results.
Create the data frame all.results, as above.
Open all.results in the viewer, by clicking on it in the Environment pane or with View(all.results).
Use str() to look at the structure of all.results.
Calculate the mean of the mon column of all.results.

What is the mean of the mon column?

0.6, from mean(all.results$mon).

On how many of the rows is pass TRUE? Use sum() to find out.

3, from sum(all.results$pass).

What is the difference between a list and a data frame?

In a data frame, all the vectors have the same length, so their values line up in rows A data frame can only hold numbers A list can only hold one vector

What next?

You have now met the core of the R language. In the Tidyverse course you will read real data from files into tibbles, choose the rows and columns you need, and draw plots with ggplot2. Before you go, open the last chapter to get your certificate.