initial commit of this file. r lecture materials.
[stats_class_2019.git] / r_lectures / w01-R_lecture.Rmd
1 ---
2 title: "Week 1 R Lecture"
3 subtitle: "Statistics and Statistical Programming  \nNorthwestern University  \nMTS 525"
4 author: "Aaron Shaw"
5 date: "April 1, 2019"
6 output: html_document
7 urlcolor: blue
8 ---
9
10 ```{r setup, include=FALSE}
11 knitr::opts_chunk$set(echo = TRUE)
12 ```
13
14
15 # Screencast #1
16 ## Very brief introduction to R (and R Studio and R Markdown)
17
18 If this is your first foray into R (or just your latest attempt), welcome! I hope this introduction helps you get started. 
19
20 This file accompanies a screencast. The idea is that you can watch the screencast with RStudio and the file open on your own machine. You can read the compiled file as an HTML document and interact with it more directly by opening the accompanying .Rmd (RMarkdown) file in R Studio.
21
22 We'll begin with a few basics. What is R? What is R Studio? What is the R Console? What is R Markdown? After that (in the second screencast), we'll move on to performing some basic operations that you'll need to understand to actually use R to perform statistical programming.
23
24 ## What is R?
25
26 R is a free software environment and programming language for statistical computing. At it's core, it's a very flexible system that you can use to conduct any kind of statistical computing you (or anyone else) can imagine. People may say "R" to refer to the language and the software environment interchangeably. You can read more about R on the [R project home page](https://www.r-project.org/about.html).
27
28 ## What is R Studio?
29
30 [R Studio](https://www.rstudio.com) is an "integrated development environment" (IDE) that you can use with R. In other words, it's an application built to make it relatively easy to conduct statistical analysis, manage datasets, generate plots, and generally interact with R in a whole varierty of ways.
31
32 R Studio has a bunch of options that you can use to adjust the look, feel, and organization of the interface. You can find them under the 'Tools' menu and 'Global Options'.
33
34 R Studio also has a number of very, very helpful keyboard shortcuts. Personally, I love keyboard shortcuts and I find that they vastly improve my experience using R Studio. If you want to learn the keyboard shortcuts, print out a copy of a cheatsheet [like this](https://github.com/rstudio/cheatsheets/raw/master/rstudio-ide.pdf) and make sure it's handy any time you even think about using R Studio. You'll improve quickly.
35
36 The most important keyboard shortcut when you're using R Studio is probably 'CTRL-Enter.' It lets you send a command from the scripting window to the R console.
37
38 ## What is the R Console?
39
40 If you're reading this in RStudio, you should see a window nearby labeled "Console." This window allows you to enter direct commands to R. You can type these commands after the little sideways caret symbol ('>') or send them to the console from a script or notebook file like this one. I will demonstrate how I do both of these things in the screencast. 
41
42 The important thing to know about the R Console is that when you type anything (a 'statement') after the sideways caret and press 'Enter' R will try to evaluate the statement and do whatever it says. If the console cannot evaluate the statement successfully, it will generate an error.
43
44 ## What is R Markdown?
45
46 This file (sample_notebook.Rmd) is an R Markdown document. Markdown is a simple formatting syntax for authoring documents that can compile in many formats, including HTML, PDF, and MS Word documents. R Markdown is an implementation of Markdown specially created to work with R. For more details on using R Markdown see <http://rmarkdown.rstudio.com>.
47
48 Think of RMarkdown notebooks as files where you can write, execute, and compile a combination of text and R code that can then be "knitted" together. When you click the **Knit** button a document will be generated that includes both the text content as well as the output of any embedded R code "chunks" within the document. You can embed an R code chunk like this:
49
50 ```{r cars}
51 summary(cars)
52 ```
53
54 That chunk calls a built-in function 'summary' to provide information about a built-in dataset called 'cars'. R has many built-in functions and a few built-in datasets. We'll come back to them later. For now, the point is that you can see how RMarkdown integrates text and code.
55
56 Embedding a new code chunk is easy. There is an 'Insert chunk' option in the 'Code' menu as well as an 'Insert' dropdown at the top of the .Rmd window. You can also use the CTRL-ALT-i keyboard shortcut (recommended!).
57
58 RMarkdown also lets you format text in a variety of ways including *italics* and **bold**.[^1] While it is not required for my course, I strongly recommend that you do your problem sets using R Markdown. The results will be clean, easy-to-read HMTL files that can integrate R code, analysis output, and graphics.
59
60 [^1]: It even does footnotes!
61
62 ### Including Plots in R Markdown
63
64 You can also embed plots, for example:
65
66
67 ```{r pressure, echo=FALSE}
68 plot(pressure)
69 ```
70
71 Note that the `echo = FALSE` parameter was added to the code chunk to prevent printing of the R code that generated the plot. It is sometimes helpful to run code chunks without printing them.
72
73 ## Some other basics of R Studio
74
75 R Studio is being very actively developed and has many features that I don't know much/anything about. You can learn a **lot** more on the R Studio site and online (more on that in a moment). For now, I want to make sure you know how to do a few other things that will make it possible to complete your assignments for my class.
76
77 ### Setting preferences and options
78
79 The appearance and some features of R studio can be customized "globally" (across all projects) through the 'Global options' item in the 'Tools' menu. For example, I prefer a darker editor theme that feels more relaxing on my eyes.
80
81 ### Working with projects
82
83 An R Studio 'project' is a bundle of data, code, figures, output, and more that you want to keep bundled together. A project might contain multiple data files or notebooks. It also might contain other material such as a README file (documentation), supplementary materials, or a finished paper. For the purposes of class, you should treat each problem set as a project. **I ask you to submit each problem set as an entire (compressed) project directory.** For the purposes of the rest of your life, what counts as a project is really up to you.
84
85 R Studio projects are saved as '.Rproj' files accompanied by whatever else the project may entail. You can open them with R Studio and/or create new ones from the 'File' menu (select 'New Project'). Note that R studio can have multiple scripts open, but seems to only be able to have one project open at a time.
86
87 ### Creating and saving a new R Markdown script
88
89 Creating new R Markdown scripts is also very straightforward in R Studio. From the 'File' menu, select 'New File' and 'R Markdown'. This will let you define some key attributes of the new file and automatically populate the .Rmd with some basic information.
90
91 ### Getting help
92
93 There are many, many ways to get help figuring out how to do things in R, R Studio, and R Markdown. I'll talk more about getting help with R functions in the second Screencast, but for now you should make sure you also have some idea of where/how to look things up when you have questions about R Studio or R Markdown. For example, try out the 'Help' menu items and identify some of the cheatsheets (like the one I mentioned earlier) that you think you might want to have around while you're learning to use these tools. The R Studio website links to several other resources and tutorials that you might find useful. [StackOverflow](https://www.stackoverflow.com) also has extensive Q&A activity for questions about R, R Studio, Markdown, and related topics. 
94
95
96
97 \newpage
98
99 # Screencast #2
100 ## Basics of R
101
102 This second screencast focuses on building basic skills with R. It can/will be far more interactive. The rest of the R Markdown script is intentionally short and is basically just an outline of the topics that will be covered. Please run these commands and experiment with R yourself in parallel as you watch/listen. 
103
104 ## Using R as a calculator
105
106 R is a very fast calculator. You can enter simple arithmetic operations (addition, subtraction, multiplication, division, exponentiation) directly into the console or via your scripts, e.g.:
107
108
109 ```{r}
110 2 + 2
111 6/3
112 10^5
113 ```
114
115 Try entering some others at the console yourself!
116
117 ## Variables
118
119 In R, you can use variables to do many things. The basic idea is that a variable allows you to 'assign' a value or set of values to a name. You indicate assignment by typing `<-` (keyboard shortcut: 'Alt--') or `=`. Here's an example:
120
121 ```{r}
122 x <- 2
123 x
124 ```
125
126 In the first line, I assigned a value of '2' to be called 'x'. In the second line, I just type 'x', which tells R to print the value for x. Surprise, surprise, it prints '2'. (More on why it also prints `[1]` in a moment...)
127
128 Try this out yourself at the R console. Then try assigning another value to 'x' and ask R to print x again. 
129  
130 For the most part, you can assign any value or set of values to any variable name and you can then use the variable name instead of the value(s):
131
132 ```{r}
133 cups.of.coffee <- 3
134 cups.of.coffee + 1
135 cups.of.coffee*3
136 ```
137
138 Some variable names and words are 'special', however, in that R has pre-assigned values to them or pre-assigned functions. We will encounter many of these. For one example of a pre-assigned variable, try typing `pi` at the console and press 'Enter'.
139
140 One other special value a variable may take is `NA` (no quotes!) which means it is missing. If a value is missing, you may not be able to do mathematical operations with it:
141
142 ```{r}
143 cups.of.coffee <- NA
144 cups.of.coffee-1
145 ```
146
147 ## Types (also known as classes)
148
149 Every variable has a 'type' or 'class'. For example, we've already created a few variables which are 'numeric'. These can be whole integers or have decimals. If you ever want to know what a variable's type is, you can ask R to tell you using the `class()` function like this: 
150
151 ```{r}
152 class(x)
153 ```
154
155 We'll come back to functions in a moment. In the meantime, other important types of variables are are 'characters' and 'logical':
156
157 ```{r}
158 my.name <- "Aaron"
159 class(my.name)
160 my.answer <- TRUE ## Note the capitalization!
161 class(my.answer)
162 ```
163
164 It is often important to know what class a variable is because R lets you perform some operations on certain kinds of variables, but not on others.
165
166 ## Functions
167
168 In R, you use functions to do just about everything (e.g., inquire about the class or type of a variable as we did above). Every function takes some input (called an argument) usually in parentheses and provides some output (sometimes called the return value). Some functions take multiple inputs and return multiple outputs. You can also write your own functions and edit existing functions. This is part of what makes R so powerful and flexible.
169
170 Arguably the most important function is `help()`. The help function will retrieve the documentation for any function. To learn more about help, try entering `help(help)` at the console.
171
172 Another useful function allows you to delete a variable: `rm()` or `remove()`. Try creating a variable and removing it.
173
174 There are many built in functions. Some are common mathematical operations like `sqrt()`, `log()`, or `log1p()`. Others help you manage your workspace like `ls()`. 
175
176 Check your reference card for many, many more examples.
177
178 ## Vectors
179
180 You can think of a vector as a set of things that are all the same type. In R, all variables are vectors even though they may have just one thing in them! That's why the R Console prints out `[1]` next to the value of a variable with just one value:
181
182 ```{r}
183 my.name
184 ```
185
186 You can make vectors with a special function `c()`:
187
188 ```{r}
189 ages <- c(36, 50, 38)
190 ages
191
192 ```
193 Vectors can be of any type but they can have only one type: 
194 ```{r}
195 class(ages)
196 painters <- c("frida", "diego", "daniel")
197 class(painters)
198 ```
199
200 If you mix types vectors together, they will be "coerced" to a single type. The results be surprising (and sometimes annoying).
201
202 ```{r}
203 class(c(ages, painters)) ## Notice that you can "nest" functions within each other!
204 ```
205 ### Indexing
206
207 You can index the elements in a vector using square brackets and a number like this:
208
209 ```{r}
210 painters[2]
211 ```
212 You can also use indexing to refer to multiple elements in a vector
213 ```{r}
214 painters[2:3] ## A sequence of the second and third elements
215 ```
216 You can even assign new values to an item (or add items) in a vector using indexing:
217
218 ```{r}
219 ages[2] <- 52
220 ages
221 ```
222
223 ### Recycling
224
225 Mathematical operations are "recycled" when applied to a vector:
226
227 ```{r}
228 ages*2
229 ages/2
230 ```
231
232 ### Naming items
233
234 You can apply a name to any item in a vector
235 ```{r}
236 names(ages)
237 names(ages) <- c("Wilma", "Fred", "Barney")
238 names(ages)
239 ```
240 Now you can index into 'ages' using the name of each item:
241 ```{r}
242 ages["Barney"]
243 ```
244
245 ### Working with vectors with multiple elements
246
247 Some functions are very handy for working with vectors that have multiple elements:
248
249 ```{r}
250 length(ages)
251 sum(ages)
252 mean(ages)
253 sd(ages) ## Standard deviation. More on that later.
254 sort(ages)
255 range(ages)
256 summary(ages)
257 table(ages)
258 ```
259
260 You can also construct new vectors by performing logical comparisons on an existing vector:
261
262 ```{r}
263 ages < 39
264 ages != 38
265
266 painters == "Diego"
267 painters == "diego"
268 painters != "frida"
269 ```
270
271 This is very useful for indexing and recoding a variable. In this case I'll use the built-in variable 'rivers' which is the lengths in miles of 141 major North American rivers (type `help(rivers)` to learn more) :
272
273 ```{r}
274 rivers
275 head(rivers) ## 'head()' shows you the first five values of a vector
276 rivers < 300 ## Recycles the comparison and returns TRUE or FALSE for each river
277 rivers[rivers < 300] ## A subset of the data
278
279 little.rivers <- rivers[rivers < 300]
280 big.rivers <- rivers; big.rivers[big.rivers < 300] <- NA ## Two commands, one line. Recodes the short rivers as 'Missing'
281 ```
282
283 ## Basic plotting and visualizations
284
285 Visualizations can help you explore data and interpret results. Use them often!
286
287 ```{r}
288 table(rivers>300)
289 hist(rivers)
290 boxplot(rivers)
291 ```
292
293
294 ## Packages 
295
296 By default, R has many built-in functions and example datasets. However, many people have extended R by creating additional functions. Often these additional functions are collected together and distributed as "packages" or "libraries" that may also include additional datasets. Rstudio gives you a couple of ways to work with these. The traditional method is via the following commands (note the use of 'eval=FALSE' in the .Rmd file means that R will not execute the code — I've done that because this generates a bunch of output we don't need and you only need to install each package once anyway):
297
298 ```{r eval=FALSE}
299
300 install.packages("UsingR") ## note the quotation marks. This package accompanies the Verzani book.
301 install.packages("openintro") ## This package goes along with our textbook.
302
303 ## Then you can load the package this way:
304 library(UsingR) ##  No quotes!
305 library(openintro)
306 ```
307 Run these commands on your system. Use the 'Packages' tab to explore the documentation of the functions and datasets available through the `openintro` package.
308
309 ## Loading datasets
310
311 Often datasets will be located online or locally on your computer and you'll want to load them directly. For '.Rdata' files you can do this using the `load()` command. For others you may want to use commands like `read.csv()`, `read.table()`, or `read.foreign()` (that last one requires the 'foreign' package, so you'll need to load it first). RStudio also has a drop-down menu item ('File' → 'Import dataset') that can help you load a local file.
312
313 ## Environment and History
314
315 By default, R Studio allows you to see all the variables or 'objects' currently available to you in a particular session. Find the window/tab called "Environment" and take a look at what's there.
316
317 There's another tab (likely in the same window) called "History" that contains all the commands you have run in the current session. This can be super helpful when you're trying to piece together what you did a few moments ago or why that command you just ran worked and the one you tried a before did not.
318
319 ## Getting help
320
321 As mentioned earlier, the `help()` command is your friend. RStudio also has a 'Help' tab in one of the default windows. You can also use the RStudio cheatsheets, StackOverflow, the Verzani textbook, the [Quick-R tutorials](https://www.statmethods.net/index.html), and/or many, many other resources on the internet, including the [rseek search engine](https://rseek.org/) (which just searches the web for R-related resources).

Community Data Science Collective || Want to submit a patch?