-
Notifications
You must be signed in to change notification settings - Fork 9
/
07-functions.Rmd
189 lines (140 loc) · 6.95 KB
/
07-functions.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
---
layout: page
title: R for reproducible scientific analysis
subtitle: Creating functions
minutes: 45
---
```{r, include=FALSE}
source("tools/chunk-options.R")
opts_chunk$set(fig.path = "fig/07-functions/", cache = TRUE)
# Silently load in the data so the rest of the lesson works
gapminder <- read.csv("data/gapminder-FiveYearData.csv", header=TRUE)
library(tidyverse)
```
> ## Learning objectives {.objectives}
>
> * Define a function that takes arguments.
> * Return a value from a function.
> * Test a function.
> * Set default values for function arguments.
> * Explain why we should divide programs into small, single-purpose functions.
>
Any operation you will perform more than once can be put into a function. That way, rather than retyping all the commands (and potentially making errors), you can simply call the function, passing it a new dataset or parameters. This may seem cumbersome at first, but writing functions to automate repetitive tasks is incredibly powerful. E.g. each time you call `ggplot` you are calling a function that someone wrote. Imagine if each time you wanted to make a plot you had to copy and paste or write that code from scratch!
### Defining a function
Recall the components of a function. E.g. the `log` function (see `?log`) takes "arguments" `x` and `base` and "returns" the base-`base` logarithm of `x`. Functions take arguments as input and yield return-values as output. You can define functions to do any number of operations on any number of arguments, but always output a single return value (however there are complex objects into which you can put multiple objects, should you need to).
Let's start by defining a simple function to add two numbers. This is the basic structure, which you can read as "assign to the variable `my_sum` a function that takes arguments `a` and `b` and returns `the_sum`." The body of the function is delimited by the curly-braces. The statements in the body are indented. This makes the code easier to read but does not affect how the code operates.
```{r}
my_sum <- function(a, b) {
the_sum <- a + b
return(the_sum)
}
```
Notice that no numbers were summed when we ran that code, but now the Environment has an object called `my_sum` that has type function. You can call `my_sum` just like you would any other function. When you do, the code between the curly-braces of the `my_sum` definition is run with whatever values you pass to `a` and `b` substituted in their place.
```{r}
my_sum(a = 2, b = 2)
my_sum(3, 4)
```
Just like `log` provides a default value of `base` (`exp(1)`) so that you don't have to type it every time, you can provide default values to any arguments of your function. Then if the user doesn't specify them, the defaults will be used.
```{r}
my_sum2 <- function(a = 1, b = 2) {
the_sum <- a + b
return(the_sum)
}
my_sum2()
my_sum2(b = 7)
```
> ## Tip {.callout}
>
> One feature unique to R is that the return statement is not required.
> R automatically returns the output of the last line of the body
> of the function unless a `return` statement is specified elsewhere.
> Since other languages require a `return` statement and because it can make
> reading a funciton easier, we will explicitly define the return statement.
#### Temperature conversion
Let’s define a function F_to_K that converts temperatures from Fahrenheit to Kelvin:
```{r}
F_to_K <- function(temp) {
K <- ((temp - 32) * (5 / 9)) + 273.15
return(K)
}
```
Calling our own function is no different from calling any other function:
```{r}
# freezing point of water
F_to_K(32)
```
```{r}
# boiling point of water
F_to_K(212)
```
> #### Challenge 1 {.challenge}
>
> - Write a function called `K_to_C` that takes a temperature in K
> and returns that temperature in C
> - Hint: To convert from K to C you subtract 273.15
> - Create a new R script, copy `F_to_K` and `K_to_C` in it, and save it as
> functions.R in the `code` directory of your project.
#### `source()`ing functions
You can load all the functions in your `code/functions.R` script without even opening the file, via the `source` function. This allows you to keep your functions separate from the analyses which use them.
```{r, eval = FALSE}
source('code/functions.R')
```
#### Combining functions
The real power of functions comes from mixing, matching and combining them
into ever large chunks to get the effect we want.
> #### Challenge 2 {.challenge}
>
> - Write a new function called `F_to_C` in your functions.R file that converts
> temperature directly from F to C by reusing the two functions above.
> - Load the function not by highlighting the code but by `source`-ing your functions.R file.
> - Use the function to find today's high temperature in your location in C.
>
### A more-useful function
Let's write a function to calculate countries' GDPs in their local currency.
- Start with Canada, exchange rate is 1.279098
- Turn that into a function that takes country and exchange rate.
- Here is a [table of exchange rates for many countries](https://raw.githubusercontent.com/michaellevy/gapminder-R/gh-pages/data/simple_exchange_rate.csv).
- Call the function with some row
- lapply over rows
### Do by joins
And by year
- Get all the exchange rates over time. You can [download that here](https://raw.githubusercontent.com/michaellevy/gapminder-R/gh-pages/data/exchange_rate.csv).
- join, filter
> #### Tip: Pass by value {.callout}
>
> Functions in R almost always make copies of the data to operate on
> inside of a function body. When we modify `dat` inside the function
> we are modifying the copy of the gapminder dataset stored in `dat`,
> not the original variable we gave as the first argument.
>
> This is called "pass-by-value" and it makes writing code much safer:
> you can always be sure that whatever changes you make within the
> body of the function, stay inside the body of the function.
>
> #### Tip: Function scope {.callout}
>
> A related concept is scoping: any variables you
> create or modify inside the body of a function only exist for the lifetime
> of the function's execution. When we call `calcGDP`, the variables `dat`,
> `years`, and `filteredDF` only exist inside the body of the function. Even if we
> have variables of the same name in our interactive R session, they are
> not modified in any way when executing a function.
>
> #### Challenge -- A new function {.challenge}
>
>
> Write a new function that takes two arguments, the gapminder data.frame and the name of a country, and plots the change in the country's population over time. That is, the return value from the function should be a ggplot object.
> - It is often easier to modify existing code than to start from scratch. Feel free to start with the calcGDP function code.
### Challenge solutions
> #### Solution -- A new function {.challenge}
>
> ```{r}
> plotPopGrowth <- function(countrytoplot, dat = gapminder) {
> df <- filter(dat, country == countrytoplot)
> plot <- ggplot(df, aes(year, pop)) +
> geom_line()
> return(plot)
> }
> plotPopGrowth('Canada')
> ```
>