R Basics

Introduction to the R programming language

Author

Matthew DeHaven

Published

February 2, 2026

Lecture Goals

R Basics
- Variable assignment and types
- Data.frames
Control Flow
- If statements, loops, apply

What is R?

a programming language
open source (free!)

. . .

Why is it called R?

Created in the 1990s by Ross Ihaka and Robert Gentleman at the University of Auckland (in New Zealand)
A successor to the programming language “S”

. . .

Created as a programming language for statistics and graphics.

Why R for this class?

Created as a programming language for statistics and graphics
- This is what we do as economists!

. . .

Used more outside academia than STATA

. . .

IMO, easier to learn than Python or Julia
- But also is a good stepping stone to those languages

. . .

It is the language I know best

Why R for this class?

Chart showing Usage Shares of Programming Languages in Economics Research (2023).

Taken from Economics and R Blog of Sebastian Kranz. Calculated from file extensions used in replication packages for published papers in economics.

R Basics

Arithmetic

2 + 2

[1] 4

5 - 2

[1] 3

2 * 4

[1] 8

9 / 2

[1] 4.5

2 ^ 2

[1] 4

Arithmetic

Order of operations as expected

2 + 2 * 2 ^ 2

[1] 10

. . .

Modulo

9 %/% 2

[1] 4

9 %% 2

[1] 1

Logic

Booleans are objects that are either TRUE or FALSE

They are very useful.

. . .

2 > 3

[1] FALSE

2 < 3

[1] TRUE

. . .

2 == 2

[1] TRUE

2 >= 2

[1] TRUE

Logic

“And” operator &
“Or” operator |

. . .

TRUE & FALSE

[1] FALSE

TRUE | FALSE

[1] TRUE

. . .

“Negation” operator !

!FALSE

[1] TRUE

!TRUE

[1] FALSE

Logic

Value Matching %in%

Compares if object on left is “in” the object on the right¹

. . .

2 %in% 1:10

[1] TRUE

2 %in% 5:10

[1] FALSE

. . .

What is the : operator? “Sequence”

1:10

 [1]  1  2  3  4  5  6  7  8  9 10

Logic

Computers handle decimals in odd ways!

0.2 + 0.2 == 0.4

[1] TRUE

0.1 + 0.2 == 0.3

[1] FALSE

? ? ?

. . .

Because computers use binary, cannot represent 0.1 exactly

Same as we cannot represent 1/3 in base 10 exactly

. . .

all.equal(0.1 + 0.2, 0.3)

[1] TRUE

https://floating-point-gui.de/basic/

Assignment

In R, we use a special “arrow” operator for assignment: <-

x <- 2
x

[1] 2

. . .

This lets us declare new variables or objects.

y <- 3

x + y

[1] 5

. . .

Why not use =?

Technically you can in R, but <- is preferred becauase = is used to assign values for a function call.

Sequences

We have seen the “sequence” operator :

Which it turns out is just a shortcut for seq()

1:10

 [1]  1  2  3  4  5  6  7  8  9 10

seq(1,10)

 [1]  1  2  3  4  5  6  7  8  9 10

. . .

But the function gives more options

seq(1, 10, by = 2)

[1] 1 3 5 7 9

seq(1, 10, length.out = 4)

[1]  1  4  7 10

Help!

How do we know all of the options for a function?

Documentation!

. . .

All R functions have a help file explaining them, which can be accessed using

help(seq)

?seq

. . .

This documentation is also hosted online.

Comments

Commenting code can be useful to yourself and others.

In R, commments are any line that begins with #

# This is a comment

## Also a comment

. . .

In VS Code

comment out a block of code: ⌘k⌘c
uncomment a block of code: ⌘k⌘u

. . .

## I use ## for actual comments
## and # for commenting out code
# x <- 5
# x

Comment Malpractice: All cap notes

Never use the following:

## TODO

## HARD CODED

## CHANGE WHEN XXXXX

## UPDATED ON XXXXX

## Set to X to run Y analysis

. . .

All of this is important information!

But it shouldn’t be stored as a comment.

Instead we should use a task manager, variables declared at the top of a script, git for version control, etc.

Comment Malpractice: Duplicating the Code

You may be tempted to add this sort of comment

## Adding 5 to my variable and squaring it
x <- (x + 5)^2

. . .

But what happens when you decide to change your code?

. . .

## Adding 5 to my variable and squaring it
x <- (x + 5)^3

If someone else reads your code, do they trust

the comment, or
the code?

. . .

Code forces you to do exactly what you say (i.e. square, not cube). But comments do not, so they tend to get out of sync with the code.

Commenting Best Practices

“Good code does not need comments”

This is the goal.

Your code should be readable without any comments.

. . .

But that’s probably unrealisitc for most of us.

Some good rules:

Comments should not duplicate code
Good comments do not excuse unclear code
Comments should dispel confusion, not cause it

. . .

These and more from: Best Practices for Writing Code Comments

My commenting practice

I like to use comments to give sections to my code

## Reading in the data


## Runnning regressions


## Making Charts


## Storing results

I find this useful as a way to structure my code and make it more readable later on.

Data Types

Data Types in R

Character
Logical (“boolean”)

. . .

Integer
Numeric

. . .

Complex (imaginary numbers)
Raw (bytes)

. . .

class("text")

[1] "character"

Character type

Characters (a.k.a. “strings”) store text information

. . .

You can create a character variable with either '' or ""

x <- 'some text'
y <- "some text"
class(x)

[1] "character"

class(y)

[1] "character"

Logical type

We saw logical types before. Stored as TRUE or FALSE.

class(TRUE)

[1] "logical"

class(FALSE)

[1] "logical"

. . .

A special type of logical in R are missing values, stored as NA

class(NA)

[1] "logical"

. . .

Missing values always create more missing values

NA == 5

[1] NA

Integer type

All whole numbers (no decimal): (…, -2, -1, 0, 1, 2, …)

An exact number storage, compared to the approximate “numeric” type.

. . .

To create an integer value, add an L at the end of the number

class(1)

[1] "numeric"

class(1L)

[1] "integer"

. . .

Can be useful for setting ID values,

but usually we will store numbers as “numeric” type instead.

Numeric

Numeric is a class that stores numbers as floating point values.

think of this as a very long decimal, but not infinite

. . .

In R, “double” is the only numeric type.

Equivalent to “float64” in other languages.

. . .

There used to be a “single” precision. Equivalent to “float32”.

. . .

class(1)

[1] "numeric"

class(1.23143)

[1] "numeric"

class(pi)

[1] "numeric"

class(1L / 3L)

[1] "numeric"

Converting from one type to another

R has a full set of as.___() functions for each type.

x <- 12
as.character(x)

[1] "12"

as.integer(x)

[1] 12

as.raw(x) # Hexidecimal representation of bytes

[1] 0c

. . .

Sometimes the conversion is not as expected.

as.logical(x)

[1] TRUE

. . .

Sometimes will return missing.

as.numeric("text")

Warning: NAs introduced by coercion

[1] NA

Automatic Conversions

Some languages are very strict about data types, R is not.

This is convenient, but somewhat dangerous.

. . .

paste() takes multiple strings and pastes them together

paste("Hello", "World!")

[1] "Hello World!"

. . .

R will try to convert other types to a string to paste.

paste("Hello", 123)

[1] "Hello 123"

paste("Hello", TRUE)

[1] "Hello TRUE"

. . .

This also happens for math operations. Can be unexpected.

TRUE * FALSE + 5

[1] 5

Data Structures

vector
matrix / array
list
data.frame
factor

Vectors

Vectors are an ordered set of values all of the same type.

They are created with the c() function (short for “concatenate”).

x <- c(1, 5, 3, 7, 10)
x

[1]  1  5  3  7 10

is.vector(x)

[1] TRUE

. . .

Technically, everything we have seen are vectors of length 1.

is.vector(1)

[1] TRUE

class(c(1, 5, 3))

[1] "numeric"

Vectors

Vectors all have lengths.

x <- c("a", "d", "b", "z")
length(x)

[1] 4

. . .

Vectors can have names for each element.

names(x) <- c("NameOne", "NameTwo", "NameThree", "NameFour")
x

  NameOne   NameTwo NameThree  NameFour 
      "a"       "d"       "b"       "z"

. . .

Vectors can have NA values, but otherwise, no mixing types.

c(1, 2, "a")

[1] "1" "2" "a"

c(1, 2, NA)

[1]  1  2 NA

Accessing Vector Elements

Vector elements can be accessed by their position, or name,

or using square brackets[].

x <- c("providence", "boston", "new york")
x[2]

[1] "boston"

. . .

names(x) <- c("p", "b", "ny")
x["b"]

       b 
"boston"

. . .

You can select multiple elements if you wish.

x[c(1,2)]

           p            b 
"providence"     "boston"

Applying Functions to Vectors

A lot of fuctions are “vectorized” to apply to each element.

x <- c(1, 5, NA, 3, 8)

x ^ 2

[1]  1 25 NA  9 64

. . .

1 + x

[1]  2  6 NA  4  9

. . .

is.na(x)

[1] FALSE FALSE  TRUE FALSE FALSE

. . .

Some functions instead take in a vector.

sum(x)

[1] NA

. . .

sum(x, na.rm = TRUE)

[1] 17

. . .

We will learn later how to vectorize any function.

Matrices and Arrays

Vectors are only one dimensional.

Matrices have 2 dimensions.

matrix(1:4, nrow = 2)

     [,1] [,2]
[1,]    1    3
[2,]    2    4

Arrays have ‘n’ dimensions.

array(1:8, dim = c(2,2,2))

, , 1

     [,1] [,2]
[1,]    1    3
[2,]    2    4

, , 2

     [,1] [,2]
[1,]    5    7
[2,]    6    8

Lists

What if I need to store a mix of data types? - Use a list!

x <- list(1, 2, "a", TRUE)
x

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] "a"

[[4]]
[1] TRUE

Each element has preserved its type!

Accessing Lists

We can again access list elements by their index position.

x <- list(1, 2, "a", TRUE)
x[3]

[[1]]
[1] "a"

. . .

Note: x[3] returns a list with one element

. . .

Use double square brackets to return the element instead.

x[[3]]

[1] "a"

Named lists

Lists can also have names for each element. We can assign them using names() or at construction.

. . .

x <- list(p = "Providence", b = "Boston", nyc = "New York")
x

$p
[1] "Providence"

$b
[1] "Boston"

$nyc
[1] "New York"

. . .

We can access list elements using the dollar sign $, followed by the element name.

x$b

[1] "Boston"

Lists of vectors

We saw earlier that 1 element objects are actually vectors.

This means that we can have lists of multiple element vectors.

x <- list(v1 = c(1, 3, 9, 5), v2 = c("A", "D", "E"))
x

$v1
[1] 1 3 9 5

$v2
[1] "A" "D" "E"

Lists of lists

We can also have lists of lists!

x <- list(l1 = list(5:7, c("A", "D", "E")), l2 = list(1:5, TRUE))
x

$l1
$l1[[1]]
[1] 5 6 7

$l1[[2]]
[1] "A" "D" "E"


$l2
$l2[[1]]
[1] 1 2 3 4 5

$l2[[2]]
[1] TRUE

. . .

This can be as many list layers deep as you want.

Lists vs. vectors

Lists are much more general than vectors.

So why use vectors?

. . .

Vectors, by enforcing a single type, are much more efficient.

. . .

Also, functions generally won’t apply to each element in a list by default.

x <- list(1, 2, 5)

x^2

<simpleError in x^2: non-numeric argument to binary operator>

Data.frames

Think of them as “tables” of elements.

. . .

x <- data.frame(col1 = c(5, 2, 7), col2 = c("f", "a", "e"))
x

  col1 col2
1    5    f
2    2    a
3    7    e

. . .

Behind the scenes, they are a

list of vectors,
where each vector has the same length.

Accessing data.frame elements

Data.frame values can be accesesd using index values:

x[row, col]

x[2, 2]

[1] "a"

. . .

You can leave one index blank to get a whole row or column.

x[2, ]

  col1 col2
2    2    a

x[ , 2]

[1] "f" "a" "e"

. . .

Or use the column names (remember, they are just lists).

x$col2

[1] "f" "a" "e"

What is your data structure?

The function str() will return information about the data structure of the passed object.

str(data.frame(col1 = c(5, 2, 7), col2 = c("f", "a", "e")))

'data.frame':   3 obs. of  2 variables:
 $ col1: num  5 2 7
 $ col2: chr  "f" "a" "e"

str(c(1, 2, 5))

 num [1:3] 1 2 5

str(list(1, 2, 5))

List of 3
 $ : num 1
 $ : num 2
 $ : num 5

str(TRUE)

 logi TRUE

Factors

A specific type of vector.

. . .

Details to be covered in the problem set!

Controlling Program Flow

If Statements

If statements evaluate a condition,

and then execute code if the condition is TRUE.

x <- 3 
if (x == 3) {
  print("X is equal to 3")
}

[1] "X is equal to 3"

. . .

If we give another value for x…

x <- 5
if (x == 3) {
  print("X is equal to 3")
}

. . .

Nothing is printed. Because print() was never run.

Mulitple if statements

Sometimes you want to check a series of conditions,

x <- "5"
if (is.numeric(x)) {
  print("X is a number.")
} else if (is.character(x)) {
  print("X is a character.")
}

[1] "X is a character."

. . .

This code,

Checks if ‘x’ is a number, then
Checks if ‘x’ is a character.

Catching everything `else`

To catch any cases that do not pass any condition, you can use

x <- NA
if (is.numeric(x)) {
  print("X is a number.")
} else if (is.character(x)) {
  print("X is a character.")
} else {
  print("I'm not sure what X is.")
  str(x)
}

[1] "I'm not sure what X is."
 logi NA

. . .

If (and if-else) statements are the basics of controlling the flow of your program.

. . .

You can make sections of code that only execute for one dataset, or a robustness check that runs on only one model.

Loops

Loops are another key component for controlling your program flow.

Two basic loops are:

for(){}
while(){}

For Loops

For loops execute code for a defined number of times.

. . .

for (i in 1:3) {
  print(i)
}

[1] 1
[1] 2
[1] 3

. . .

The construction here is

for (each_value in vector_of_values) {
  ## Do something
}

While Loops

While loops execute code repeatedly until a condition is met.

i <- 1
while (i <= 3) {
  print(i)
  i <- i + 1
}

[1] 1
[1] 2
[1] 3

. . .

Here we emulated the function of the for loop from before.

. . .

But while loops only require one thing:

while (condition) {
  ## Do Something
}

Dangerous While Loops

It is easy to write a while loop that will run forever.

while (1 < 3) {
  print("running!")
}

. . .

This one is inane, but you can inadevertantly construct them.

Why use While Loops?

While loops let you execute code for an unspecified duration.

x <- 0
while (x < 1) {
  x <- rnorm(1)
  print(x)
}

[1] -0.03751376
[1] -1.574604
[1] -0.4859675
[1] 0.4651862
[1] -0.9040981
[1] -0.2774328
[1] 0.3864344
[1] -0.06040412
[1] -0.6861798
[1] -1.906137
[1] 1.80376

Setting Safety Valves

If you are going to use a while loop, it’s a good idea to set a “safety” option to limit the maximum number of iterations.

. . .

max_iter <- 1000
i <- 0
x <- 0
while (x < 1 & i < max_iter) {
  x <- rnorm(1)
  i <- i + 1
}
print(i)

[1] 3

print(x)

[1] 1.106937

Apply Functions

There are some disadvantages to loops,

. . .

They tend to be inefficient

. . .

The sometimes go on forever

. . .

One alternative is to use one of the family of apply() functions.

`lapply()`

We will see how to use the l + apply() function.

. . .

l stands for “list”, which is what the function returns.

. . .

We can rewrite our prior for(){} loop as,

x <- lapply(1:3, print)

[1] 1
[1] 2
[1] 3

. . .

The construction is…

results_as_list <- lapply(vector_of_values, function_applied_to_each_value)

`lapply()`

One nice thing about lapply() is it returns the values as list.

lapply(1:3, sqrt)

[[1]]
[1] 1

[[2]]
[1] 1.414214

[[3]]
[1] 1.732051

. . .

It also works with lists as the input,

lapply(list(1, 2, 3), sqrt)

[[1]]
[1] 1

[[2]]
[1] 1.414214

[[3]]
[1] 1.732051

Why are Apply Functions More Efficient?

Apply functions assume that each of your elements can be operated on separately.

. . .

For loops operate on each element sequentially.

. . .

This makes it much faster for computers to handle apply functions.

. . .

But sometimes you will have operations that depend on prior steps, and you will have to use for loops.

Summary

Introduced to R
- “Calculator” operations and logic
- Assigning values
- Different data types (logical, character, numeric, etc.)
- Different data structures (vectors, lists, data.frames, etc.)
Control Flow
- If Else
- Loops
- lapply()

Live Coding Example

Comparing a for loop to lapply()
- Sum each vector in a list of vectors

num_list <- list(a = 1:5, b = 6:10, c = 11:15)

In Class Exercise

Create a vector from 1 to 20.
Write a for loop that iterates through each element of the vector.
Inside the loop, use an if statement to check if the current element is even or odd.
Print “Even” if the element is even and “Odd” if the element is odd.

Footnotes

purposefully vague for now, we will talk about lists soon↩︎

Lecture Goals

What is R?

Why R for this class?

Why R for this class?

R Basics

Arithmetic

Arithmetic

Logic

Logic

Logic

Logic

Assignment

Sequences

Help!

Comments

Comment Malpractice: All cap notes

Comment Malpractice: Duplicating the Code

Commenting Best Practices

My commenting practice

Data Types

Data Types in R

Character type

Logical type

Integer type

Numeric

Converting from one type to another

Automatic Conversions

Data Structures

Data Structures

Vectors

Vectors

Accessing Vector Elements

Applying Functions to Vectors

Matrices and Arrays

Lists

Accessing Lists

Named lists

Lists of vectors

Lists of lists

Lists vs. vectors

Data.frames

Accessing data.frame elements

What is your data structure?

Factors

Controlling Program Flow

If Statements

Mulitple if statements

Catching everything else

Loops

For Loops

While Loops

Dangerous While Loops

Why use While Loops?

Setting Safety Valves

Apply Functions

lapply()

lapply()

Why are Apply Functions More Efficient?

Summary

Summary

Live Coding Example

In Class Exercise

Footnotes

Catching everything `else`

`lapply()`

`lapply()`