Ch 5 - Data transformation

5.1 Introduction

Visualisation is an important tool for insight generation, but it is rare that you get the data in exactly the right form you need. Often you’ll need to create some new variables or summaries, or maybe you just want to rename the variables or reorder the observations in order to make the data a little easier to work with. You’ll learn how to do all that (and more!) in this chapter, which will teach you how to transform your data using the dplyr package and a new dataset on flights departing New York City in 2013.

5.1.1 Prerequisites

In this chapter we’re going to focus on how to use the dplyr package, another core member of the tidyverse. We’ll illustrate the key ideas using data from the nycflights13 package, and use ggplot2 to help us understand the data.

library(nycflights13)
library(tidyverse)

Take careful note of the conflicts message that’s printed when you load the tidyverse. It tells you that dplyr overwrites some functions in base R. If you want to use the base version of these functions after loading dplyr, you’ll need to use their full names: stats::filter() and stats::lag().

5.1.2 nycflights13

To explore the basic data manipulation verbs of dplyr, we’ll use nycflights13::flights. This data frame contains all 336,776 flights that departed from New York City in 2013. The data comes from the US Bureau of Transportation Statistics, and is documented in ?flights.

flights

You might notice that this data frame prints a little differently from other data frames you might have used in the past: it only shows the first ffew rows and all the columns that fit on one screen. (To see the whole dataset, you can run View(flights) which will open the dataset in the Rstudio viewer). It prints differently because it’s a tibble. Tibbles are data frames, but slightly tweaked to work better in the tidyverse. For now, you don’t need to worry about the differences; we’ll come back to tibbles in more detail in wrangle.

You might have also noticed the row of three (or four) letter abbreviations under th ecolumn names. These describe the type of each variable:

• int stands for integers.
• dl stands for doubles, or real numbers
• chr stands for character vectors, or strings.
• dttm stands for date-times (a date + a time).

There are three other common types of variables that aren’t used in this dataset but you’ll encounter later in the book:

• lgl stands for logical, vectors that contain only TRUE or FALSE.
• fctr stands for factors, which R uses to represent categorical variables with fixed possible values.
• date stands for dates.

5.1.3 dplyr basics

In this chapter you are going to learn the five key dplyr functions that allow you to solve the vast majority of your data manipulation challenges:

• Pick observations by their values (filter()).
• Reorder the rows(arrange()).
• Pick variables by their names(select()).
• Create new variables with functions of existing variables (mutate()).
• Collapse many values down to a single summary (summarise()).

All verbs work similarly:

1. The first argument is a data frame.
2. The subsequent arguments describe what to do with the data frame, using the variable names (without quotes).
3. The result is a new data frame.

Together these properties make it easy to chain together multiple simple steps to achieve a complex result. Let’s dive in and see how these verbs work.

5.2 Filter rows with filter()

filter() allows you to subset observations based on their values. The first agument is the name of the data frame. The second and subsequent arguments are the expressions that filter the data frame. For example, we can select all flights on January 1st with:

filter(flights, month == 1, day == 1)

When you run that line of code, dplyr executes the filtering operation and returns a new data frame. dplyr functions never modify their inputs, so if you want to save the result, you’ll need to use the assignment operator <-:

dec25 <- filter(flights, month == 12, day == 25)
dec25

R either prints out the results, or saves them to a variable. If you want to do both, you can wrap the assignment in parentheses:

(jan1 <- filter(flights, month == 1, day == 1))

5.2.1 Comparisons

To use filtering effectively, you have to know how to select the observations that you want using the comparison operators. R provides the standard suite: >, >=, <, <=, !- (not equal), and == (exactly equal to).

When you’re starting out with R, the easieset mistake to make is to use = instead of == when testing for equality. When this happens you’ll get an informative error:

filter(flights, month = 1)

Error: Problem with `filter()` input `..1`.
x Input `..1` is named.
ℹ This usually means that you've used `=` instead of `==`.
ℹ Did you mean `month == 1`?
Run `rlang::last_error()` to see where the error occurred.

There’s another common problem you might encounter when using ==: floating point numbers. These results might surprise you!

sqrt(2)^2 == 2

[1] FALSE

1/49 * 49 == 1

[1] FALSE

Computeres use finite precision arithmetic (they obviously can’t store an infinite number of digits!) so remember that every number you see is an approximation. Instead of relying on ==, use near():

near(sqrt(2)^2, 2)

[1] TRUE

near(1/49*49, 1)

[1] TRUE

5.2.2 Logical Operators

Multiple arguments to filter() are combined with “and”: every expression must be true in order for a row to be included in the output. For other types of combinations, you’ll need to use Boolean operators yoursef: & is “and”, | is “or”, and ! is “not”.

filter(flights, month == 11)

filter(flights, month == 12)

filter(flights, month == 11 | month == 12)

The order of operations doesn’t work like English. You can’t write filter(flights, month == 11 | 12)), which you might literally translate into “finds all flights that departed in November or December”. Instead it finds all months that equal 11 | 12, an expression that evaluates to TRUE. In a numeric context (like here), TRUE becomes one, so this finds all flights in January, not November or December. This is quite confusing!

A useful short-hand for this problem is x %in% y. This will select every row where x is one of the values in y. We could use it to rewrite the code above:

nov_dec <- filter(flights, month %in% c(11,12))
nov_dec

Sometimes you can simplify complicated subsetting by remembering De Morgan’s law: !(x & y) is the same as !x | !y, and !(x | y) is the same as !x & !y. For example, if you wanted to find flights that weren’t delayed (on arrival or departure) by more than two hours, you could use either of the following filters:

filter(flights, arr_delay <= 120 & dep_delay <= 120)

filter(flights, arr_delay <= 120, dep_delay <= 120)

filter(flights, !(arr_delay > 120 | dep_delay > 120))

filter(flights, !(arr_delay >120), !(dep_delay >120))

As well as & and |, R also has && and ||. Don’t use them here! You’ll learn when you should use them in conditional execution.

Whenever you start using complicated, multipart expressions in filter(), consider making them explicit variables instead., That makes it much easier to check your work. You’ll learn how to create new variables shortly.

5.2.3 Missing values

One important feature of R that can make comparison tricky are missing values, or NAs (“not availables”). NA represents an unknown value so missing values are “contagious”: almost any operation involving an unknown values will also be unknown.

NA > 5

[1] NA

10 == NA

[1] NA

NA + 10

[1] NA

NA / 2

[1] NA

The most confusing result is this one:

NA == NA

[1] NA

It’s easiest to understand why this is true with a bit more context:

# Let x be Mary's age. We don't know how old she is.
x <- NA

# Let y be John's age. We don't know how old he is.
y <- NA

# Are John and Mary the same age?
x == y

[1] NA

# We don't know!

If you want to determine if a value is missing, use is.na():

is.na(x)

[1] TRUE

filter() only includes rows where the condition is TRUE; it excludes both FALSE and NA values. If you want to preserve missing values, ask for them explicitly:

df <- tibble(x = c(1, NA, 3))
filter(df, x > 1)

filter(df, is.na(x) | x > 1)

5.2.4 Exercises

1. Find all flights that

2. Had an arrival delay of two or more hours

filter(flights, arr_delay >= 120)

2. Flew to Houston (IAH or HOU)

filter(flights, dest == "IAH" | dest == "HOU")

3. Were operated by United, American, or Delta

airlines

# Need "AA", "DL" and "UA"
filter(flights, carrier %in% c("AA", "DL", "UA"))

4. Departed in summer (July, August, and September)

filter(flights, month %in% 7:9)

OR

filter(flights, month >= 7 & month <= 9)

5. Arrived more than two hours late, but didn’t leave late

filter(flights, arr_delay > 120 & dep_delay <= 0)

6. Were delayed by at least an hour, but made up over 30 minutes in flight

filter(flights, dep_delay >= 60 & arr_delay < dep_delay - 30)

filter(flights, dep_delay >= 60 & dep_delay - arr_delay > 30)

7. Departed between midnight and 6am (inclusive)

summary(flights$dep_time)

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
      1     907    1401    1349    1744    2400    8255 

filter(flights, dep_time <= 600 | dep_time == 2400)

2. Another useful dplyr filtering helper is between(). What does it do? Can you use it to simplify the code needed to answer the previous challenges?

?between
# Departed in summer problem
filter(flights, between(month, 7, 9))

3. How many flights have a missing dep_time? What other variables are missing? What might these rows represent?

filter(flights, is.na(dep_time))

8,255 rows have a missing dep_time. Dep_delay, arr_time, arr_delay, and air_time are also missing. These rows likely represent cancelled flights or missing data (more likely cancelled flights).

You can also use summary() to find the number of NAs for each variable.

summary(flights)

      year          month             day           dep_time    sched_dep_time
 Min.   :2013   Min.   : 1.000   Min.   : 1.00   Min.   :   1   Min.   : 106  
 1st Qu.:2013   1st Qu.: 4.000   1st Qu.: 8.00   1st Qu.: 907   1st Qu.: 906  
 Median :2013   Median : 7.000   Median :16.00   Median :1401   Median :1359  
 Mean   :2013   Mean   : 6.549   Mean   :15.71   Mean   :1349   Mean   :1344  
 3rd Qu.:2013   3rd Qu.:10.000   3rd Qu.:23.00   3rd Qu.:1744   3rd Qu.:1729  
 Max.   :2013   Max.   :12.000   Max.   :31.00   Max.   :2400   Max.   :2359  
                                                 NA's   :8255                 
   dep_delay          arr_time    sched_arr_time   arr_delay          carrier         
 Min.   : -43.00   Min.   :   1   Min.   :   1   Min.   : -86.000   Length:336776     
 1st Qu.:  -5.00   1st Qu.:1104   1st Qu.:1124   1st Qu.: -17.000   Class :character  
 Median :  -2.00   Median :1535   Median :1556   Median :  -5.000   Mode  :character  
 Mean   :  12.64   Mean   :1502   Mean   :1536   Mean   :   6.895                     
 3rd Qu.:  11.00   3rd Qu.:1940   3rd Qu.:1945   3rd Qu.:  14.000                     
 Max.   :1301.00   Max.   :2400   Max.   :2359   Max.   :1272.000                     
 NA's   :8255      NA's   :8713                  NA's   :9430                         
     flight       tailnum             origin              dest          
 Min.   :   1   Length:336776      Length:336776      Length:336776     
 1st Qu.: 553   Class :character   Class :character   Class :character  
 Median :1496   Mode  :character   Mode  :character   Mode  :character  
 Mean   :1972                                                           
 3rd Qu.:3465                                                           
 Max.   :8500                                                           
                                                                        
    air_time        distance         hour           minute     
 Min.   : 20.0   Min.   :  17   Min.   : 1.00   Min.   : 0.00  
 1st Qu.: 82.0   1st Qu.: 502   1st Qu.: 9.00   1st Qu.: 8.00  
 Median :129.0   Median : 872   Median :13.00   Median :29.00  
 Mean   :150.7   Mean   :1040   Mean   :13.18   Mean   :26.23  
 3rd Qu.:192.0   3rd Qu.:1389   3rd Qu.:17.00   3rd Qu.:44.00  
 Max.   :695.0   Max.   :4983   Max.   :23.00   Max.   :59.00  
 NA's   :9430                                                  
   time_hour                  
 Min.   :2013-01-01 05:00:00  
 1st Qu.:2013-04-04 13:00:00  
 Median :2013-07-03 10:00:00  
 Mean   :2013-07-03 05:22:54  
 3rd Qu.:2013-10-01 07:00:00  
 Max.   :2013-12-31 23:00:00  
                              

4. Why is NA^0 not missing? Why is NA | TRUE not missing? Why is FALSE & NA not missing? Can you figure out the general rule? (NA *0 is a tricky counterexample!)

NA^0

[1] 1

5.3 Arrange rows with arrange()

arrange() works similarly to filter() except that instead of selecting rows, it changes their order. It takes a data frame and a set of column names (or more complicated expressions) to order by. If you provide more than one column name, each additional column will be used to break ties in the values of preceding columns:

arrange(flights, year, month, day)

Use desc() to re-order by a column in descending order:

arrange(flights, desc(dep_delay))

Missing values are always sorted at the end:

(df <- tibble(x = c(5, 2, NA)))

arrange(df, x)

arrange(df, desc(x))

5.3.1 Exercises

1. How could you use arrange() to sort all missing values to the start? (Hint: use is.na()).

arrange(flights, desc(is.na(dep_time)))

2. Sort flights to find the most delayed flights. Find the flights that left earliest.

arrange(flights, desc(dep_delay))

arrange(flights, dep_delay)

3. Sort flights to find the fastest (highest speed) flights.

arrange(flights, desc(distance/air_time))

4. Which flights travelled the farthest? Which travelled the shortest?

arrange(flights, desc(distance))

arrange(flights, distance)

5.4 Select columns with select()

It’s not uncommon to get datasets with hundreds or even thousands of variables. In this case, the first challenge is often narrowing in on the variables you’re actually interested in. select() allows you to rapidly zoom in on a useful subset using operations based on the names of the variables.

select() is not terribly useful with the flights data because we only have 19 variables but you can still get the general idea:

# Select columns by name
select(flights, year, month, day)

# Select all columns between year and day
select(flights, year:day)

# Select all columns except those from year to day (inclusive)
select(flights, -(year:day))

There are a number of helper functions you can use within select():

• starts_with(“abc”): matches names that begin with “abc”.
• ends_with(“xyz”): matches names that end with “xyz”.
• __contains(“ijk”): matches names that contain “ijk”.
• matches("(.)\1): selects variables that match a regular expression. This one matches any variables that contain repeated characters. You’ll learn more about regular expressions in strings.
• __num_range(“x”, 1:3): matches x1, x2, and x3.

See ?select for more details.

select() can be used to rename variables, but it’s rarely useful because it drops all of the variables not explicitly mentioned. Instead, use rename(), which is a variant of select() that kepps all the variables that aren’t explicitly mentioned:

rename(flights, tail_num = tailnum)

Another option is to use select() in conjunction with the everything() helper. This is useful if you have a handful of variables you’d like to move to the start of the data frame.

select(flights, time_hour, air_time, everything())

5.4.1 Exercises

1. Brainstorm as many ways as possible to select dep_time, dep_delay, arr_time, and arr_delay from flights.

select(flights, dep_time, dep_delay, arr_time, arr_delay)

select(flights, dep_time:arr_delay, -c(sched_dep_time, sched_arr_time))

select(flights, starts_with("dep") | starts_with("arr") & ends_with("time") | ends_with("delay"))

select(flights, c(dep_time, dep_delay, arr_time, arr_delay))

select(flights, 4, 6, 7, 9)

select(flights, "dep_time", "dep_delay", "arr_time", "arr_delay")

2. What happens if you include the name of a variable multiple times in a select() call?

select(flights, dep_time, arr_time, dep_time, arr_time)

It will recognize duplicate calls and only include a single column of the doubly-specified variable.

3. What does the any_of() function do? Why might it be helpful in conjunction with this vector?

any_of() is a selection helper which helps select variables contained within a character vector. It does not check for missing variables and is especially useful with negative selections, when you would like to make sure a variable is removed.

vars <- c("year", "month", "day", "dep_delay", "arr_delay")
vars

[1] "year"      "month"     "day"       "dep_delay" "arr_delay"

?any_of

Essentially, any_of and all_of have replaced one_of with the main difference being that the two work similarly when all variables are present, but when any variable is not present the all_of function generates an error message.

They are useful though in the event that you want to make calls to this select statement frequently and it generates a character vector that is easier to work with than constantly using "".

4. Does the result of running the following code surprise you? How do the select helpers deal with case by default? How can you change that default?

select(flights, contains("TIME"))

The result is suprising because R is generally case-sensitive. By default the select helpers ignore case (ignore.case). To change this we could specify ignore.case = FALSE.

select(flights, contains("TIME", ignore.case = FALSE))

5.5 Add new variables with mutate()

Besides selecting sets of existing columns, it’s often useful to add new columns that are functions of existing columns. That’s the job of mutate().

mutate() always adds new columns at the end of your dataset so we’ll start by creating a narrower dataset so we can see the new variables. Remember that when you’re in RStudio, the easiest way to see all the columns is View().

(flights_sml <- select(flights,
                      year:day,
                      ends_with("delay"),
                      distance,
                      air_time
                      ))

mutate(flights_sml,
       gain = dep_delay - arr_delay,
       speed = distance / air_time * 60
       )

Note that you can refer to columns you’ve just created:

mutate(flights_sml,
       gain = dep_delay - arr_delay,
       hours = air_time / 60,
       gain_per_hour = gain / hours
       )

If you only want to keep the new variables, use transmute():

transmute(flights,
          gain = dep_delay - arr_delay,
          hours = air_time / 60,
          gains_per_hour = gain / hours
          )

5.5.1 Useful creation functions

There are many functions for creating new variables that you can use with mutate(). The key propoerty is that the function must be vectorised: it must take a vector of values as input, return a vector with the same number of values as output. There’s no way to list every possible function that you might use, but here’s a selection of functions that are frequently useful:

• Arithmetic operators: __+, -, *, /, ^__. These are all vectorised, using the so called “recycling rules”. If one paramater is shorter than the other, it will be automatically extended to be the same length. This is most useful when one of the arguments is a single number: air_time / 60, hours * 60 + minute, etc..

Arithmetic operators are also useful in conjunction with the aggregate functions you’ll learn about later. For example, x / sum(x) calculates the proportion of a total, and y - mean(y) computes the difference from the mean.

• Modular arithmetic: %/% (integer division) and %% (remainder), where x == y * (x %/% y) + (x %% y). Modular arithmetic is a handy tool because it allows you to break integers up into pieces. For example, in the flights dataset, you can compute hour and minute from dep_time with:

transmute(flights,
          dep_time,
          hour = dep_time %/% 100,
          minute = dep_time %% 100
          )

• Logs: log(), log2(), log10(). Logarithms are an incredibly useful transformation for dealing with data that ranges across multiple orders of magnitude. They also convert multiplicative relationships to additive, a feature we’ll come back to in modelling.

All else being equal, I recommend using log2() because it’s easy to interpret: a difference of 1 on the log scale corresponds to doubling on the original scale and a difference of -1 corresponds to halving.

• Offsets: lead() and lag() allows you to refer to leading or lagging values. This allows you to compute running differences (e.g. x - lag(x)) or find when values change (x != lag(x)). They are most useful in conjunction with group_by(), which you’ll learn about shortly.

(x <- 1:10)

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

lag(x)

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

lead(x)

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

• Cumulative and rolling aggregates: R provides functions for running sums, products, mins and maxes: cumsum(), cumprod(), cummin(), cummax(); and dplyr provides cummean() for cumulative means. If you need rolling aggregates (i.e. a sum computed over a rolling window), try the RcppRoll package.

x

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

cumsum(x)

 [1]  1  3  6 10 15 21 28 36 45 55

cummean(x)

 [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5

• Logical comparisons, <, <=, >, >=, !=, and ==, which you learned about earlier. If you’re doing a complex sequence of logical operations it’s often a good idea to store the iterim values in new variables so you can check that each step is working as expected.

• Ranking: there are a number of ranking functions, but you should start with min_rank(). It does the most usual type of ranking (e.g. 1st, 2nd, 2nd, 4th). The default gives smallest values the small ranks; use desc(x) to give the largest values the smallest ranks.

y <- c(1, 2, 2, NA, 3, 4)
min_rank(y)

[1]  1  2  2 NA  4  5

min_rank(desc(y))

[1]  5  3  3 NA  2  1

If min_rank() doesn’t do what you need, look at the variants row_number(), dense_rank(), percent_rank(), cume_dist, ntile(). See their help pages for more details.

row_number(y)

[1]  1  2  3 NA  4  5

dense_rank(y)

[1]  1  2  2 NA  3  4

dense_rank(desc(y))

[1]  4  3  3 NA  2  1

percent_rank(y)

[1] 0.00 0.25 0.25   NA 0.75 1.00

cume_dist(y)

[1] 0.2 0.6 0.6  NA 0.8 1.0

5.5.2 Exercises

1. Currently dep_time and sched_dep_time are convenient to look at, but hard to compute with because they’re not really continuous numbers. Convert them to a more convenient representation of number of minutes since midnight.

transmute(flights,
          dep_time,
          dep_time_hours = dep_time %/% 100,
          dep_time_minutes = dep_time %% 100,
          dep_time_minutes_since_midnight = (dep_time_hours * 60) + dep_time_minutes,
          sched_dep_time,
          sched_dep_time_hours = sched_dep_time %/% 100,
          sched_dep_time_minutes = sched_dep_time %% 100,
          sched_dep_time_minutes_since_midnight = (sched_dep_time_hours * 60) + sched_dep_time_minutes
          )

transmute(flights,
          dep_time_minutes_since_midnight = (dep_time %/% 100 * 60) + (dep_time %% 100) %%
            1440,
          sched_dep_time_minutes_since_midnight = (sched_dep_time %/% 100 * 60) +
          (sched_dep_time %% 100) %% 1440
          )

time2mins <- function(x) {
  (x %/% 100 * 60) + (x %% 100) %% 1440
}

transmute(flights,
          dep_time_minutes_since_midnight = time2mins(dep_time),
          sched_dep_time_minutes_since_midnight = time2mins(sched_dep_time)
          )

2. Compare air_time with arr_time - dep_time. What do you expect to see? What do you see? What do you need to do to fix it?

We would expect that the difference between departure and arrival time would simply be the flight time or exactly equal to the air time. However, we see that the variable we have created “flight_time” differs from air_time. This is because the arr_time and dep_time are not continuous variables incidicating minutes, they are time stamps so subtracting these numbers produces a time stamp indicating the concatenated hour and minutes of flight. The first values “313” indicates that the difference between arr_time and dep_time was 3 hours and 13 minutes. To fix this we need to convert arrival and departure time to minutes as we did in the previous problem.

sml_set <- select(flights,
                  arr_time,
                  dep_time,
                  air_time
                  )

mutate(sml_set,
       flight_time = arr_time - dep_time
)

(sml_set <- mutate(sml_set,
          flight_time = (time2mins(arr_time) - time2mins(dep_time))
          ))

nrow(filter(sml_set, air_time != flight_time))

[1] 327150

It appears as though the values are still different. Specifically, there are 327,150 cases cases where air_time and our fligh_time variable differ. Our flight_time variable is the true number of minutes between the arr_time and dep_time. However it is possible that there are differences existing, possibly due to some flight rolling over into the next day (past midnight) and perhaps with time zone changes?

Took some time to review and mess around with ggplots.

ggplot(data = flights) +
       geom_boxplot(mapping = aes(x = carrier, y = air_time))

ggplot(data = flights) +
  geom_bar(mapping = aes(x = carrier, y = stat(count/sum(count)), fill = origin))

3. Compare dep_time, sched_dep_time, and dep_delay. How would you expect those three numbers to be related.

We would expect the dep_delay to be the difference of dep_time and sched_dep_time. It appears that that in fact is the case measured in minutes.

We would expect that the dep_time and sched_dep_time would be the same, but what we want to compare are the dep_delay and the dep_delay2 variable we created to check to see that they have the same minimums, maximums, means, etc and that there are no instances where the values are not equal..

However, as we see there are 1,207 instances where values differ.

times_delays <- mutate(flights,
                       dep_time_minutes = time2mins(dep_time),
                       sched_dep_time_minutes = time2mins(sched_dep_time),
                       dep_delay_diff = dep_delay - (dep_time_minutes -                                             sched_dep_time_minutes))

select(times_delays,
       dep_time_minutes,
       sched_dep_time_minutes,
       dep_delay_diff)

nrow(filter(times_delays, dep_delay_diff != 0))

[1] 1207

ggplot(data = filter(times_delays, dep_delay_diff > 0),
                     mapping = aes(x = dep_delay_diff, y = sched_dep_time_minutes)) +
geom_point()  

4. Find the 10 most delayed flights using a ranking function. How do you want to handle ties? Carefully read the documentation for min_rank().

# Quick way to get the 10 flights with the longest departure delays.
arrange(flights, desc(dep_delay))

?min_rank

rankme <- tibble(x = c(10,5,1,5,5))
rankme

rankme <- mutate(rankme,
                 x_row_number = row_number(x),
                 x_min_rank = min_rank(x),
                 x_dense_rank = dense_rank(x)
                 )
arrange(rankme, x)

flights_delayed <- mutate(flights,
                          dep_delay_row_number = row_number(desc(dep_delay)),
                          dep_delay_min_rank = min_rank(desc(dep_delay)),
                          dep_delay_dense_rank = dense_rank(desc(dep_delay))
                          )

select(flights_delayed,
       dep_delay,
       dep_delay_row_number,
       dep_delay_min_rank,
       dep_delay_dense_rank
)

flights_delayed <- filter(flights_delayed,
                          dep_delay_row_number <= 10 | dep_delay_min_rank <= 10 | dep_delay_dense_rank <= 10)

select(flights_delayed,
       dep_delay,
       dep_delay_row_number,
       dep_delay_min_rank,
       dep_delay_dense_rank
)

flights_delayed <- select(flights_delayed,
       dep_delay,
       dep_delay_row_number,
       dep_delay_min_rank,
       dep_delay_dense_rank
       )

arrange(flights_delayed, dep_delay_min_rank)

5. What does 1:3 + 1:10 return? Why?

1:3 + 1:10

longer object length is not a multiple of shorter object length

 [1]  2  4  6  5  7  9  8 10 12 11

It returns the above error message. It occurs due to how R handles arithmetic operations of vectors of different lengths. These two vectors would appear as such.

(a <- 1:3)

[1] 1 2 3

(b <- 1:10)

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

So the resulting equation would be -> (1+1) + (2+2+) + (3+3) + (1+4) + (2+5) + (3+6) …

Thus, R recycles the shorter vector to create a vector of the same length as the longer vector. Addition of two vectors of different lengths is often done accidentally.

6. What trigonometric functions does R provide?

?Trig

all Trigonometric functions can be found and examined using the above help article.

5.6 Grouped summaries with summarise()

The last key verb is summarise(). It collapses a data frame to a single row:

summarise(flights, delay = mean(dep_delay, na.rm = TRUE))

summarise() is not terribly useful unless we pair it with group_by(). This changes the unit of analysis from the complete dataset to individual groups. Then, when you use the dply verbs on a grouped data frame they’ll be automatically applied “by group”. For example, if we applied exactly the same code to a data frame grouped by data, we get the average delay per date:

by_day <- group_by(flights, year, month, day)
summarise(by_day, delay = mean(dep_delay, na.rm = TRUE))

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

Together group_by() and summarise() provide one of the tools that you’ll use most commonly when working with dplyr: grouped summaries. But before we go any further with this, we need to introduce a powerful new idea: the pipe.

5.6.1 Combining multiple operations with the pipe

Imagine that we want to explore the relationship between the distance and average delay for each location. Using what you know about dplyr, you might write code like this:

by_dest <- group_by(flights, dest)
delay <- summarise(by_dest,
                   count = n(),
                   dist = mean(distance, na.rm = TRUE),
                   delay = mean(arr_delay, na.rm = TRUE)
                   )

delay

delay <- filter(delay, count > 20 & dest != "HNL")

delay

ggplot(data = delay, mapping = aes(x = dist, y = delay)) +
         geom_point(aes(size = count, alpha = 1/3)) +
  geom_smooth(se = FALSE)

It appears that flights with longer distances between airports have shorter delays, perhaps because some time can be made up on longer flights?

There are three steps to prepare this data:

1. Group flights by destination.
2. Summarise to compute distance, average delay, and number of flights.
3. Filter to remove noisy points and Honolulu airport, which is almost wice as far away as the next closest airport.

This code is a little frustrating to write because we have to give each intermediate data frame a name, even though we don’t care about it. Naming things is hard, so this slows down our analysis:

There’s another way to tackle the same problem with the pipe, %>%:

delays <- flights %>%
  group_by(dest) %>%
  summarise(
    count = n(),
    dist = mean(distance, na.rm = TRUE),
    delay = mean(arr_delay, na.rm = TRUE)
  ) %>%
  filter(count > 20 & dest != "HNL")

ggplot(data = delays, mapping = aes(x = dist, y = delay)) +
  geom_point(aes(size = count, alpha = 1/3)) +
  geom_smooth(se = FALSE)

This focuses on the transformations, not what’s being transformed, which makes the code easier to read. You can read it as a series of imperative statements: group, then summarise, then filter. As suggested by this reading, a good way to pronounce %>% when reading code is “then”.

Behind the scenes, x %>% f(y) turns f(x, y) and x %>$ f(y) %>% g(z) turns into g(f(x,y),z) and so on. You can use the pipe to rewrite multiple operations in a way that you can read left-to-right, top-to-bottom. We’ll use piping frequently from now on because it considerably improves the readability of code, and we’ll come back to it in more detail in pipes.

Working with the pipe is one of the key criteria for belonging to the tidyverse. The only exception is ggplot2: it was written before the pipe was discovered. Unfortunately, the next iteration of ggplot2, ggvis, which does use the pipe, isn’t quite ready for prime time yet.

5.6.2 Missing values

You may have wondered about the na.rm argument we used above. What happens if we don’t set it?

flights %>%
  group_by(year, month, day) %>%
  summarise(mean = mean(dep_delay))

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

We get a lot of missing values! That’s because aggregation functions obey the usual rule of missing values: if there’s any missing value in the input, the output will be a missing value. Fortunately, all aggregation functions have an na.rm argument which removes the missing values prior to computation.

flights %>%
  group_by(year, month, day) %>%
  summarise(delay = mean(dep_delay, na.rm = TRUE))

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

In this case, where missing values represent cancelled flights, we could also tackle the problem by first removing the cancelled flights. We’ll save this dataset so we can reuse it in the next few examples.

not_cancelled <- flights %>%
  filter(!is.na(dep_delay) & !is.na(arr_delay))
  
not_cancelled %>%
  group_by(year, month, day) %>%
  summarise(mean = mean(dep_delay))

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

5.6.3 Counts

Whenever you do any aggregation, it’s always a good idea to include either a count (n()), or a count of non-missing values (sum(!is.na(x))). That way you can check that you’re not drawing conclusions based on very small amounts of data. For example, let’s look at the planes (identified by their tail number) that have the highest average delays:

plane_delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarise(delays = mean(arr_delay))

plane_delays

ggplot(data = plane_delays, mapping = aes(x = delays)) +
  geom_freqpoly(binwidth = 10)

We can get better insight if we draw a scatterplot of number of flights vs average delay:

delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarise(
    delay = mean(arr_delay, na.rm = TRUE),
    n = n()
  )

ggplot(data = delays, mapping = aes(x = n, y = delay)) +
  geom_point(alpha = 1/3)

Not surprisingly, there is much greater variation in the average delay when there are few flights. The shape of this plot is very characteristic: whenever you plot a mean (or other summary) vs. group size, you’ll see that the variation decreases as the sample size increases.

When looking at this sort of plot, it’s often useful to filter out the groups with the smallest number of observations, so you can see more of the pattern and less of the extreme variation in the smallest groups. This is what the following code does, as well as showing you a handy pattern for integrating ggplot2 into dply flows. It’s a bit painful that you have to switch from %>% to +, but once you get the hang of it it’s quite convenient.

delays %>%
  filter(n > 25) %>%
ggplot(mapping = aes(x = n, y = delay)) +
  geom_point(alpha = 1/10)

There’s another common variation of this type of pattern. Let’s look at how the average performance of batters in baseball is related to the number of times they’re at bat.

batting <- as.tibble(Lahman::Batting)

batters <- batting %>%
  group_by(playerID) %>%
  summarise(
    ba = sum(H, na.rm = TRUE)/sum(AB, na.rm = TRUE),
    ab = sum(AB, na.rm = TRUE)
)

batters %>%
  filter(ab > 100) %>%
  ggplot(data = batters, mapping = aes(x = ab, y = ba)) +
  geom_point() +
  geom_smooth(se = FALSE)

5.6.4 Useful summary functions

Just using means, counts, and sum can get you a long way, but R provides many other useful summary functions:

• Measures of location: we’ve used mean(x), but median(x) is also useful. The mean is the sum divided by the length; the median is a value where 50% of x is above it, and 50% is below it.

It’s sometimes useful to combine aggregation with logical subsetting. We haven’t talked about this sort of subsetting yet, but you’ll learn more about it in subsetting.

not_cancelled %>%
  group_by(year, month, day) %>%
  summarise(
    avg_delay1 = mean(arr_delay),
    avg_delay2 = mean(arr_delay[arr_delay > 0]) # the average positive delay
  )

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

Measures of spread: sd(x), IQR(x), mad(x). The root mean squared deviation, or standard deviation sd(x), is the standard measure of spread. The interquartile range IQR(x) and median absolute deviation mad(x) are robust equivalents that may be more useful if you have outliers.

# Why is distance to some destinations more variable than to others?
not_cancelled %>%
  group_by(dest) %>%
  summarise(distance_sd = sd(distance)) %>%
  arrange(desc(distance_sd))

• Measures of rank: min(x), quantile(x, 0.25), max(x). Quantiles are a generalisation of the median. For example, quantile(x, 0.25) will find a value of x that is greater than 25% of the values, and less than the remaining 75%.

# When do the first and last flights leave each day?
not_cancelled %>%
  group_by(year, month, day) %>%
  summarise(
    first_flight = min(dep_time, na.rm = TRUE),
    last_flight = max(dep_time, na.rm = TRUE)
  )

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

• Measures of position: first(x), nth(x, 2), last(x). These work similarly to x[1], x[2], and x[length(x)] but let you set a default value if that position does not exist (i.e. you’re trying to get the 3rd element from a group that only has two elements). For example, we can find the first and last departure for each day:

# Find the first and last departure for each day
not_cancelled %>%
  group_by(year, month, day) %>%
  summarise(
    first_flight = first(dep_time),
    last_flight = last(dep_time)
  )

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

These functions are complementary to filtering on ranks. Filtering gives you all variables, with each observation in a separate row:

not_cancelled %>%
  group_by(year, month, day) %>%
  mutate(r = min_rank(desc(dep_time))) %>%
  filter(r %in% range(r))

• Counts: You’ve seen n(), which takes no arguments, and returns the size of the current group. To count the number of non-missing values, use sum(!is.na(x))). To count the number of distinct (unique) values, use n_distinct(x).

not_cancelled %>%
  group_by(dest) %>%
  summarise(carriers = n_distinct(carrier)) %>%
              arrange(desc(carriers))

Counts are so useful that dplyr provides a simple helper if all you want is a count:

not_cancelled %>%
  count(dest)

You can optionally provide a weight variable. For example, you could use this to “count” (sum) the total number of miles a plane flew:

not_cancelled %>%
  count(tailnum, wt = distance)

• Counts and proportions of logical values: sum(x > 10), mean(y == 0). When used with numeric functions, TRUE is converted to 1 and FALSE to 0. This makes sum() and mean() very useful: sum(x) gives the number of TRUEs in x, and mean(x) gives the proportion.

# How many flights left before 5am? (these usually indicate delayed flights from the previous day)

not_cancelled %>%
  group_by(year, month, day) %>%
  summarise(
    before_5am = sum(dep_time < 500, na.rm = TRUE),
    after_5am = sum(dep_time > 500, na.rm = TRUE)
  )

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

# What proportion of flights are delayed by more than an hour?
not_cancelled %>%
  group_by(year, month, day) %>%
  summarise(
    long_delay_prop = mean(arr_delay > 60, na.rm = TRUE)
  )

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

5.6.5 Grouping by multiple variables

When you group by multiple variables, each summary peels off one level of the grouping. That makes it easy to progressively roll up a dataset:

daily <- group_by(flights, year, month, day)
(per_day <- summarise(daily, flights = n()))

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

monthly <- group_by(flights, year, month)
(per_month <- summarise(monthly, flights = n()))

`summarise()` has grouped output by 'year'. You can override using the `.groups` argument.

yearly <- group_by(flights, year)
(per_year <- summarise(yearly, flights = n()))

Be careful when progressively rolling up summaries: it’s OK for sums and counts, but you need to think about weighting means and variances, and it’s not possible to do it exactly for rank-based statistics like the median. In other words, the sum of groupwise sums is the overall sum, but the median of groupwise medians is not the overall median.

5.6.6 Ungrouping

If you need remove grouping, and return to operations on ungrouped data, use ungrou().

daily %>%
  ungroup() %>%
  summarise(flights = n())

5.6.7 Exercises

1. Brainstorm at least 5 different ways to assess the typical delay characteristics of a group of flights. Consider the following scenarios:

1. Where are flights most likely to be delayed to?
2. What airline is most usually delayed?
3. Is there a relationship between distance and arrival delays?
4. What time of year experiences the most delays?
5. Are certain planes more likely to be delayed?

Which is more important: arrival delay or departure delay?

If you’re a consumer of air travel then you probably don’t care very much if you’re flight is delayed on departure as long as it isn’t on arrival.

However, as a producer you’re probably equally concerned with both in that you don’t want to cancel flights.

2. Come up with another approach that will give you the same output as:

not_cancelled %>%
  count(dest)

not_cancelled %>%
  group_by(dest) %>%
  summarise(
    n = n()
  )

not_cancelled %>%
  count(tailnum, wt = distance)

not_cancelled %>%
  group_by(tailnum) %>%
  summarise(
    dist = sum(distance, na.rm = TRUE)
  )

3. Our definition of cancelled flights ((is.na(dep_delay) | is.na(arr_delay)) is slightly suboptimal. Why? Which is the most important column?

It is suboptimal because a flight could be delayed on departure but not have an arrival delay if it crashes before arriving or lands somewhere else instead. So the most important column is arr_delay.

filter(flights, !is.na(dep_delay), is.na(arr_delay)) %>%
  select(dep_time, arr_time, sched_arr_time, dep_delay, arr_delay)

4. Look at the number of cancelled flights per day. Is there a pattern? Is the proportion of cancelled flights related to the average delay?

summ_of_cancelled_flights <- flights %>%
  group_by(year, month, day) %>%
  summarise(
  flights = n(),
  cancelled_flights = sum(is.na(arr_delay)),
  prop_cancelled = cancelled_flights/flights,
  avg_delay = mean(arr_delay[!is.na(arr_delay)])
  )

`summarise()` has grouped output by 'year', 'month'. You can override using the `.groups` argument.

summ_of_cancelled_flights

ggplot(data = summ_of_cancelled_flights, mapping = aes(x = flights, y = cancelled_flights)) +
  geom_jitter() +
  geom_smooth(se = FALSE)

# A scatterplot of flights and cancelled flights shows a weak positive relationship between the number of flights and number of cancelled flights.

ggplot(data = summ_of_cancelled_flights, mapping = aes(x = avg_delay, y = prop_cancelled)) +
  geom_jitter() +
  geom_smooth(se = FALSE)

# There is a very strong relationship between the proportion of flights that are cancelled and the average delay. 

# This analysis just used arrival delay as we previously stated that it was the most important. The trend likely holds when examining using departure delay.

5. Which carrier has the worst delays? Challenge: can you disentangle the effects of bad airports vs. bad carriers? Why/why not? (Hint: think about flights %>% group_by(carrier, dest) %>% summarise(n()))

carrier_delays <- not_cancelled %>%
  group_by(carrier) %>%
  filter(carrier != "OO") %>%
  summarise(
    flights = n(),
    delayed = sum(arr_delay > 0),
    on_time = flights - delayed,
    prop_delayed = delayed/flights,
    avg_delay = mean(arr_delay)
  )


arrange(carrier_delays, desc(avg_delay))

arrange(carrier_delays, desc(prop_delayed))

# Which carrier has the "worst" delays depends on what you mean by "worst". F9 has the highest average delay meaning the most time when a flight is delayed, but FL has the highest proportion of flights delayed (almost 60% delayed on arrival). FL and F9 were in the top two for both categories. They are also significantly higher in terms of proportion of flights delayed and average delay time when compared to the rest of the carriers with differences of apprx. 10% in prop_delayed and 5 minutes with regards to avg_delay.

airport_delays_origin <- not_cancelled %>%
  group_by(origin) %>%
  filter(origin != "HNL") %>%
  summarise(
    flights = n(),
    delayed = sum(arr_delay > 0),
    on_time = flights - delayed,
    prop_delayed = delayed/flights,
    avg_delay = mean(arr_delay, na.rm = TRUE)
  )

airport_delays_origin

# Flights out of EWR have the highest avg_delay and proportion of flights delayed.

airport_delays_dest <- not_cancelled %>%
  group_by(dest) %>%
  filter(dest != "HNL") %>%
  summarise(
    flights = n(),
    delayed = sum(arr_delay > 0),
    on_time = flights - delayed,
    prop_delayed = delayed/flights,
    avg_delay = mean(arr_delay, na.rm = TRUE)
  )

arrange(airport_delays_dest, desc(prop_delayed))

arrange(airport_delays_dest, desc(avg_delay))

# Flights landing in CAE have the highest proportion of flights delayed and highest average delay.

flights %>%
  filter(!is.na(arr_delay)) %>%
  # Total delay by carrier within each origin, dest
  group_by(origin, dest, carrier) %>%
  summarise(
    arr_delay = sum(arr_delay),
    flights = n()
  )

`summarise()` has grouped output by 'origin', 'dest'. You can override using the `.groups` argument.

flights %>%
  filter(!is.na(arr_delay)) %>%
  # Total delay by carrier within each origin, dest
  group_by(origin, dest, carrier) %>%
  summarise(
    arr_delay = sum(arr_delay),
    flights = n()
  )  %>%
  # Total delay within each origin dest
  group_by(origin, dest) %>%
  mutate(
    arr_delay_total = sum(arr_delay),
    flights_total = sum(flights)
  )

`summarise()` has grouped output by 'origin', 'dest'. You can override using the `.groups` argument.

flights %>%
  filter(!is.na(arr_delay)) %>%
  # Total delay by carrier within each origin, dest
  group_by(origin, dest, carrier) %>%
  summarise(
    arr_delay = sum(arr_delay),
    flights = n()
  ) %>%
  # Total delay within each origin dest
  group_by(origin, dest) %>%
  mutate(
    arr_delay_total = sum(arr_delay),
    flights_total = sum(flights)
  ) %>%
  # average delay of each carrier - average delay of other carriers
  ungroup() %>%
  mutate(
    arr_delay_others = (arr_delay_total - arr_delay) /
      (flights_total - flights),
    arr_delay_mean = arr_delay / flights,
    arr_delay_diff = arr_delay_mean - arr_delay_others
  )

`summarise()` has grouped output by 'origin', 'dest'. You can override using the `.groups` argument.

flights %>%
  filter(!is.na(arr_delay)) %>%
  # Total delay by carrier within each origin, dest
  group_by(origin, dest, carrier) %>%
  summarise(
    arr_delay = sum(arr_delay),
    flights = n()
  ) %>%
  # Total delay within each origin dest
  group_by(origin, dest) %>%
  mutate(
    arr_delay_total = sum(arr_delay),
    flights_total = sum(flights)
  ) %>%
  # average delay of each carrier - average delay of other carriers
  ungroup() %>%
  mutate(
    arr_delay_others = (arr_delay_total - arr_delay) /
      (flights_total - flights),
    arr_delay_mean = arr_delay / flights,
    arr_delay_diff = arr_delay_mean - arr_delay_others
  ) %>%
  # remove NaN values (when there is only one carrier)
  filter(is.finite(arr_delay_diff)) %>%
  # average over all airports it flies to
  group_by(carrier) %>%
  summarise(arr_delay_diff = mean(arr_delay_diff)) %>%
  arrange(desc(arr_delay_diff))

`summarise()` has grouped output by 'origin', 'dest'. You can override using the `.groups` argument.

6. What does the sort argument to count() do? When might you use it?

The sort argument to count places the groups with the largest counts at the top.

You would use it when you want to display the groups with the highest counts at the top, it’s basically a shortcut to arrange.

flights %>%
  filter(!is.na(arr_delay)) %>%
  count(carrier, sort = TRUE)

5.7 Grouped mutates (and filters)

Grouping is most useful in conjunction with summarise(), but you can also do convenient operations with mutate() and filter():

• Find the worst members of each group:

flights %>%
  group_by(year, month) %>%
  filter(rank(desc(arr_delay)) < 10)

• Find all groups bigger than a threshold

popular_dests <- flights %>%
  group_by(dest) %>%
  select(year, month, day, dep_delay, arr_delay, distance, air_time, dest) %>%
  filter(n() > 365)

popular_dests %>%
  filter(arr_delay > 0) %>%
  mutate(prop_delay = arr_delay/sum(arr_delay)) %>%
  select(year:day, dest, arr_delay, prop_delay)

5.7.1 Exercises

1. Refer back to the lists of useful mutate and filtering functions. Describe how each operation changes when you combine it with grouping.

Summary functions (mean()), offset functions (lead(), lag()), ranking functions (min_rank(), row_number()), operate within each group when used with group_by() in mutate() or filter(). Arithmetic operators (+, -), logical operators (<, ==), modular arithmetic operators (%%, %/%), logarithmic functions (log) are not affected by group_by.

Summary functions like mean(), median(), sum(), std() and others covered in the section Useful Summary Functions calculate their values within each group when used with mutate() or filter() and group_by().

Arithmetic operators +, -, *, /, ^ are not affected by group_by().

The modular arithmetic operators %/% and %% are not affected by group_by()

The logarithmic functions log(), log2(), and log10() are not affected by group_by()

The offset functions lead() and lag() respect the groupings in group_by(). The functions lag() and lead() will only return values within each group.

The cumulative and rolling aggregate functions cumsum(), cumprod(), cummin(), cummax(), and cummean() calculate values within each group.

Logical comparisons, <, <=, >, >=, !=, and == are not affected by group_by().

Ranking functions like min_rank() work within each group when used with group_by().

2. Which plane (tailnum) has the worst on-time record?

“Worst” meaning:

1. % of flights delayed
2. avg delay

flights %>%
  filter(!is.na(tailnum)) %>%
  mutate(on_time = !is.na(arr_time) & arr_delay <= 0) %>%
  group_by(tailnum) %>%
  summarise(
    flights = n(),
    on_time = mean(on_time)
  ) %>%
  filter(flights >= 20) %>%
    filter(min_rank(on_time) == 1)

# avg delay
flights %>%
  filter(!is.na(arr_delay)) %>%
  mutate(delayed = !is.na(arr_delay) & arr_delay > 0) %>%
  group_by(tailnum) %>%
  summarise(flights = n(),
            prop_delayed = mean(delayed)) %>%
  filter(flights > 20) %>%
  filter(min_rank(desc(prop_delayed)) == 1)

NA
NA

flights %>%
  filter(!is.na(arr_delay)) %>%
  mutate(delayed = !is.na(arr_delay) & arr_delay > 0) %>%
  group_by(tailnum) %>%
  summarise(flights = n(),
            flights_delayed = sum(delayed),
            tot_delay = sum(arr_delay),
            avg_delay = mean(arr_delay),
            prop_delayed = mean(delayed)
            ) %>%
  filter(flights > 20) %>%
  filter(min_rank(desc(avg_delay)) == 1)

3. What time of day should you fly if you want to avoid delays as much as possible?

flights %>%
  filter(!is.na(arr_time)) %>%
  group_by(hour) %>%
  mutate(delayed = !is.na(arr_delay) & arr_delay > 0) %>%
  summarise(
    flights = n(),
    prop_delay = mean(delayed)
  ) %>%
  filter(min_rank(prop_delay) == 1)

# 7 am had the lowest proportion of flights delayed

4. For each destination, compute the total minutes of delay. For each flight, compute the proportion of the total delay for its destination.

flights %>%
  filter(!is.na(arr_delay) & arr_delay > 0) %>%
  group_by(dest) %>%
  mutate(dest_delay = sum(arr_delay), prop_flight_delay = arr_delay/dest_delay) %>%
  select(dest, month, day, dep_time, flight, arr_delay, dest_delay, prop_flight_delay) %>%
  arrange(dest, desc(prop_flight_delay))

flights %>%
  filter(!is.na(arr_delay) & arr_delay > 0) %>%
  group_by(dest, origin, carrier, flight) %>%
  summarise(
    arr_delay = sum(arr_delay)) %>%
  group_by(dest) %>%
  mutate(dest_arr_delay_total = sum(arr_delay),
         prop_arr_flight_delay = arr_delay/dest_arr_delay_total) %>%
  arrange(dest, desc(prop_arr_flight_delay)) %>%
  select(carrier, flight, origin, dest, prop_arr_flight_delay)

`summarise()` has grouped output by 'dest', 'origin', 'carrier'. You can override using the `.groups` argument.

5. Delays are typically temporally correlated: even once the problem that caused the initial delay has been resolved, later flights are delayed to allow earlier flights to leave. Using lag(), explore how the delay of a flight is related to the delay of the immediately preceding flight.

(Skipped)

6. Look at each destination. Can you find flights that are suspiciously fast? (i.e. flights that represent a potential data entry error). Compute the air time of a flight relative to the shortest flight to that destination. Which flights were most delayed in the air?

flights %>%
  filter(arr_delay < 0) %>%
  select(carrier, flight, origin, dest, arr_delay) %>%
  arrange(arr_delay)

# What would be suspicious? If a flight arrived more than an hour ahead of its scheduled arrival time?

flights %>%
  filter(arr_delay < -60) %>%
  select(carrier, flight, origin, dest, arr_delay) %>%
  arrange(arr_delay)

# Apprx. 200 flights landed an hour before they were scheduled to.

flights %>%
  filter(!is.na(arr_time)) %>%
  group_by(origin, dest, carrier, flight)

7. Find all destinations that are flown by at least two carriers. Use that information to rank the carriers.

flights %>%
  group_by(dest) %>%
  mutate(n_carrier = n_distinct(carrier)) %>%
  filter(n_carrier > 1) %>%
  group_by(carrier) %>%
  summarize(n_dest = n_distinct(dest)) %>%
  arrange(desc(n_dest))

8. For each plane, count the number of flights before the first delay of greater than 1 hour.