Getting Started with R

Introduction

This interactive tutorial will introduce you to some basics commands for working with data in R. You’ll occasionally see blocks for modifying code or for writing new code from scratch.

This tutorial introduces four ideas:

Doing arithmetic with R.
Assigning values to variable names in R.
Saving lists in R.
Working with words in R.

Continue to the next section

R is a fancy calculator

The first lesson is that R is a fancy calculator. Considering the power of a computer, this might not be surprising

Using mathematic operators

The + symbol works in R like it does in most places. Try it out by hitting the “Run Code” button in the code chunk below:

We could have done simple addition like this in our heads, but not every math problem is so simple.

Now you try

Try out a few different things in the next code block. Can you figure out how to multiply 520 by 475? The “Show hint” button can help out if needed.

Other operators

Good job! We may not always need to do complicated math, but it’ll be helpful to know the operators for simple arithmetic, including addition (+), subtraction (-), multiplication (*), and division (/). More complex things will be handled by functions, which we’ll discuss in a future lesson.

Operator	Description	Example
`+`	Addition	`2 + 3` `[1] 5`
`-`	Subtraction	`2 - 3` `[1] -1`
`*`	Multiplication	`2 * 3` `[1] 6`
`/`	Division	`2 / 3` `[1] 0.6666667`
`^`	Exponent (“to the power of”)	`2 ^ 3` `[1] 8`
`( )`	Order of operations	`2 ^ (5 - 2)` `[1] 8`

The result in each of these examples is preceded by [1]. Although many of our examples only have one answer as output, we’ll later see the usefulness of these numbers in brackets when the output is a list of values spanning multiple lines.

Continue to the next section

R can save variables (or objects)

Any old calculator can add and multiply. A fancy calculator can also save values to a variable name. And here we’re talking of variables that are fancier than any you remember from algebra, where “x” and “y” ruled the day. In R, your variable names can be much fancier.

Assignment arrow

To save variables (also called “objects”), we’ll use the less-than symbol (<) and the hyphen or minus sign (-) together to make a left-pointing arrow called the “assignment arrow”: <-. This means we’re saving whatever is on the right of the arrow into the variable or object named on the left. For instance, the following code saves the value “1803” to the variable we’re calling louisiana_purchase:

When you save a variable, it’ll look like nothing has happened. But with any variable, we can type its name again to see what values are saved in it. Type louisiana_purchase below to retrieve the value saved under that name:

Using objects

Saving objects becomes useful when we don’t want to remember a value, or if we might want to change a value without changing a process. Now that we have louisiana_purchase, for instance, we can use it in some simple math to find out how many years have passed since the Louisiana purchase:

Now you try

This example is obviously pretty simple. We can imagine other scenarios, though, where objects might change their value over time while a calculation stays the same. Let’s say, for instance, that we have a sweet tooth and are ordering three pieces of pie for dessert. Each piece costs $9.78. We can calculate our bill with the following code:

But what if the cost goes up or we’re feeling exceptionally sweet-toothed? Modify the first two lines in the following code block to calculate our final cost for ordering seven pieces of pie, which now cost $13.33 each:

Solution

When the values of each variable are adjusted, it will change the result of our multiplication.

pieces_of_pie <- 7
cost_per_pie <- 13.33

pieces_of_pie * cost_per_pie

Naming objects

So far, you’ve seen names like louisiana_purchase, pieces_of_pie, and cost_per_pie. From this, we can see that letters and underscores are okay in the names of objects. Some other kinds of characters are also okay, as long as you follow a few rules:

Use names that make sense. There’s no need to name everything x or y when names can be longer. Choose a relatively short name that is clear.
Names can be made up of letters, numbers, underscores, and periods. Letters can be upper- or lower-cased. Spaces are not allowed.
Start with a letter. This letter can be upper- or lower-cased.

Working with variables like this can make it easier to think through the work that needs doing by talking it out. Using variables means we don’t have to remember specific values, but we can call them up at any time.

Midpoint Check-in

Occasionally during these lessons, you’ll see a checkpoint question (or a few of them) to help reiterate something you’ve just learned. Don’t get nervous, though; they’re here just for you to check your own understanding.

Which of the following shows the mathematic function “ten divided by four”?

Which of these operators is used for the assignment of a value to a variable name?

Identify which of the following naming conventions will work for objects in R:

name	contains	valid?
`myGrades`	mixed upper and lowercase
`my.grades`	period in middle
`my_grades`	underscore in middle
`_grades`	underscore at start
`2025grades`	numbers at start
`grades2025`	numbers at end
`my grades`	space

It’s ok if you have to think for some of these. You’ll have a chance to review everything at the end.

Continue to the next section

R can save lists

Sometimes it will come in handy to save multiple values to one variable name. Say for instance, you’re the judge of a contest for “cutest dog,” and you want to weigh every puppy when it gets entered. It may be enough just to have a list of weights listed together.

In R, we call this list of values a “vector.” (We’ll often use this word interchangeably with the word list, but it’s maybe better to use vector because the other word also has other meanings in R.) And we can save these values like this:

Defining a vector

Notice that a vector definition has three components:

There’s a c at the front.
Parentheses surround everything.
Values are separated by commas.

As with saving any variable, it’ll look at first like nothing has happened, but we can type the variable name again to see what values are saved in it:

Now you try

The following definition of a vector with four values has some problems with it. Can you fix them? When you click “Run Code” the error message should be able to give a little bit of guidance, but hints are available, too.

Solution

A well formed vector has three characteristics:

There’s a c at the front.
Parentheses surround everything.
Values are separated by commas.

kitten_weight <- c(2, 4, 5, 3)

Vector math

Vectors are especially fancy because they allow us to do math on the entire list of values at once. Let’s say, for instance, that we realized our scale was exactly one pound off, recording each dog’s weight to be one pound lighter than it actually is. Hit run below to remind yourself of the weights we’ve recorded. How would you add one pound to the dog weights?

Doing more with vectors

The nature of vectors also makes it easy to do more complex things with them. We know, for instance, that every pound is about 0.45 kilograms, so we can convert the weights with simple multiplication:

Vectors will really shine when we learn about functions in a future lesson.

Continue to the next section

R can handle words

We should also be aware that R can do fancy things with words. When we work with words, we’ll call them “strings,” which is another name for most values that aren’t numbers.

Defining strings

Here’s the secret: quotation marks. Notice in the following example code that the line of text is surrounded by quotation marks.

The technique works almost anywhere someone might otherwise use numbers, including in vectors:

Now you try

The following assignment of a string to a variable name isn’t working. Can you fix it?

Solution

Always put quotation marks around strings. (Anything that contains letters is probably a string.)

beyonce <- "Only double lines we cross is dollar signs."

beyonce

The End

That’s all for this lesson, which introduces some basic instructions for using R. The following should serve a reminder of what we learned in this tutorial:

R can calculate with typical arithmetic operators, including +, -, *, and /. Example: 2 + 2
R can save a value to a variable name by using the assignment arrow <-. Example: states <- 50
R can save multiple values in a list by using c() and separating items with commas. Example: c(1, 2, 3)
R can manage words and letters as values if they’re surrounded by quotation marks. Example: dessert <- "chocolate pie"

Show table of contents