Data Wrangling with dplyr and tidyr

Overview

Teaching: 20 min
Exercises: 10 min

Questions

How can I select specific rows and/or columns from a dataframe?

How can I combine multiple commands into a single command?

How can I create new columns or remove existing columns from a dataframe?

How can I reformat a dataframe to meet my needs?

Objectives

Describe the purpose of an R package and the dplyr and tidyr packages.

Select certain columns in a dataframe with the dplyr function select.

Select certain rows in a dataframe according to filtering conditions with the dplyr function filter.

Link the output of one dplyr function to the input of another function with the ‘pipe’ operator %>%.

Add new columns to a dataframe that are functions of existing columns with mutate.

Use the split-apply-combine concept for data analysis.

Use summarize, group_by, and count to split a dataframe into groups of observations, apply a summary statistics for each group, and then combine the results.

Describe the concept of a wide and a long table format and for which purpose those formats are useful.

Describe the roles of variable names and their associated values when a table is reshaped.

Reshape a dataframe from long to wide format and back with the pivot_wider and pivot_longer commands from the tidyr package.

Export a dataframe to a csv file.

dplyr is a package for making tabular data wrangling easier by using a limited set of functions that can be combined to extract and summarize insights from your data. It pairs nicely with tidyr which enables you to swiftly convert between different data formats (long vs. wide) for plotting and analysis.

Similarly to readr, dplyr and tidyr are also part of the tidyverse. These packages were loaded in R’s memory when we called library(tidyverse) earlier.

Note

The packages in the tidyverse, namely dplyr, tidyr and ggplot2 accept both the British (e.g. summarise) and American (e.g. summarize) spelling variants of different function and option names. For this lesson, we utilize the American spellings of different functions; however, feel free to use the regional variant for where you are teaching.

What is an R package?

The package dplyr provides easy tools for the most common data wrangling tasks. It is built to work directly with dataframes, with many common tasks optimized by being written in a compiled language (C++) (not all R packages are written in R!).

The package tidyr addresses the common problem of wanting to reshape your data for plotting and use by different R functions. Sometimes we want data sets where we have one row per measurement. Sometimes we want a dataframe where each measurement type has its own column, and rows are instead more aggregated groups. Moving back and forth between these formats is nontrivial, and tidyr gives you tools for this and more sophisticated data wrangling.

But there are also packages available for a wide range of tasks including building plots (ggplot2, which we’ll see later), downloading data from the NCBI database, or performing statistical analysis on your data set. Many packages such as these are housed on, and downloadable from, the Comprehensive R Archive Network (CRAN) using install.packages. This function makes the package accessible by your R installation with the command library(), as you did with tidyverse earlier.

To easily access the documentation for a package within R or RStudio, use help(package = "package_name").

To learn more about dplyr and tidyr after the workshop, you may want to check out this handy data transformation with dplyr cheatsheet and this one about tidyr.

Learning `dplyr` and `tidyr`

We are working with the same dataset as earlier. Refer to the previous lesson to download the data, if you do not have it loaded.

We’re going to learn some of the most common dplyr functions:

select(): subset columns
filter(): subset rows on conditions
mutate(): create new columns by using information from other columns
group_by() and summarize(): create summary statistics on grouped data
arrange(): sort results
count(): count discrete values

Selecting columns and filtering rows

To select columns of a dataframe, use select(). The first argument to this function is the dataframe (interviews), and the subsequent arguments are the columns to keep, separated by commas. Alternatively, if you are selecting columns adjacent to each other, you can use a : to select a range of columns, read as “select columns from __ to __.”

# to select columns throughout the dataframe
select(interviews, village, no_membrs)
# to select a series of connected columns
select(interviews, village:respondent_wall_type)

To choose rows based on specific criteria, we can use the filter() function. The argument after the dataframe is the condition we want our final dataframe to adhere to (e.g. village name is Chirodzo):

# filters observations where village name is "Chirodzo" 
filter(interviews, village == "Chirodzo")

# A tibble: 39 × 6
   key_ID village  interview_date      no_membrs respondent_wall_type no_meals
    <dbl> <chr>    <dttm>                  <dbl> <chr>                   <dbl>
    8 Chirodzo 2016-11-16 00:00:00        12 burntbricks                 2
    9 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
   10 Chirodzo 2016-12-16 00:00:00        12 burntbricks                 3
   34 Chirodzo 2016-11-17 00:00:00         8 burntbricks                 2
   35 Chirodzo 2016-11-17 00:00:00         5 muddaub                     3
   36 Chirodzo 2016-11-17 00:00:00         6 sunbricks                   3
   37 Chirodzo 2016-11-17 00:00:00         3 burntbricks                 3
   43 Chirodzo 2016-11-17 00:00:00         7 muddaub                     2
   44 Chirodzo 2016-11-17 00:00:00         2 muddaub                     2
   45 Chirodzo 2016-11-17 00:00:00         9 muddaub                     3
# ℹ 29 more rows

We can also specify multiple conditions within the filter() function. We can combine conditions using either “and” or “or” statements. In an “and” statement, an observation (row) must meet every criteria to be included in the resulting dataframe. To form “and” statements within dplyr, we can pass our desired conditions as arguments in the filter() function, separated by commas:

# filters observations with "and" operator (comma)
# output dataframe satisfies ALL specified conditions
filter(interviews, village == "Chirodzo", 
                   no_membrs > 4, 
                   no_meals > 2)

# A tibble: 20 × 6
   key_ID village  interview_date      no_membrs respondent_wall_type no_meals
    <dbl> <chr>    <dttm>                  <dbl> <chr>                   <dbl>
    9 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
   10 Chirodzo 2016-12-16 00:00:00        12 burntbricks                 3
   35 Chirodzo 2016-11-17 00:00:00         5 muddaub                     3
   36 Chirodzo 2016-11-17 00:00:00         6 sunbricks                   3
   45 Chirodzo 2016-11-17 00:00:00         9 muddaub                     3
   48 Chirodzo 2016-11-16 00:00:00         7 muddaub                     3
   49 Chirodzo 2016-11-16 00:00:00         6 burntbricks                 3
   51 Chirodzo 2016-11-16 00:00:00         5 muddaub                     3
   52 Chirodzo 2016-11-16 00:00:00        11 burntbricks                 3
   56 Chirodzo 2016-11-16 00:00:00        12 burntbricks                 3
   61 Chirodzo 2016-11-16 00:00:00        10 muddaub                     3
   62 Chirodzo 2016-11-16 00:00:00         5 muddaub                     3
   64 Chirodzo 2016-11-16 00:00:00         6 muddaub                     3
   65 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
   66 Chirodzo 2016-11-16 00:00:00        10 burntbricks                 3
   67 Chirodzo 2016-11-16 00:00:00         5 burntbricks                 3
   68 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
  192 Chirodzo 2017-06-03 00:00:00         9 burntbricks                 3
  199 Chirodzo 2017-06-04 00:00:00         7 burntbricks                 3
  200 Chirodzo 2017-06-04 00:00:00         8 burntbricks                 3

We can also form “and” statements with the & operator instead of commas:

# filters observations with "&" logical operator
# output dataframe satisfies ALL specified conditions
filter(interviews, village == "Chirodzo" & 
                   no_membrs > 4 & 
                   no_meals > 2)

# A tibble: 20 × 6
   key_ID village  interview_date      no_membrs respondent_wall_type no_meals
    <dbl> <chr>    <dttm>                  <dbl> <chr>                   <dbl>
    9 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
   10 Chirodzo 2016-12-16 00:00:00        12 burntbricks                 3
   35 Chirodzo 2016-11-17 00:00:00         5 muddaub                     3
   36 Chirodzo 2016-11-17 00:00:00         6 sunbricks                   3
   45 Chirodzo 2016-11-17 00:00:00         9 muddaub                     3
   48 Chirodzo 2016-11-16 00:00:00         7 muddaub                     3
   49 Chirodzo 2016-11-16 00:00:00         6 burntbricks                 3
   51 Chirodzo 2016-11-16 00:00:00         5 muddaub                     3
   52 Chirodzo 2016-11-16 00:00:00        11 burntbricks                 3
   56 Chirodzo 2016-11-16 00:00:00        12 burntbricks                 3
   61 Chirodzo 2016-11-16 00:00:00        10 muddaub                     3
   62 Chirodzo 2016-11-16 00:00:00         5 muddaub                     3
   64 Chirodzo 2016-11-16 00:00:00         6 muddaub                     3
   65 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
   66 Chirodzo 2016-11-16 00:00:00        10 burntbricks                 3
   67 Chirodzo 2016-11-16 00:00:00         5 burntbricks                 3
   68 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
  192 Chirodzo 2017-06-03 00:00:00         9 burntbricks                 3
  199 Chirodzo 2017-06-04 00:00:00         7 burntbricks                 3
  200 Chirodzo 2017-06-04 00:00:00         8 burntbricks                 3

In an “or” statement, observations must meet at least one of the specified conditions. To form “or” statements we use the logical operator for “or,” which is the vertical bar (|):

# filters observations with "|" logical operator
# output dataframe satisfies AT LEAST ONE of the specified conditions
filter(interviews, village == "Chirodzo" | village == "Ruaca")

# A tibble: 88 × 6
   key_ID village  interview_date      no_membrs respondent_wall_type no_meals
    <dbl> <chr>    <dttm>                  <dbl> <chr>                   <dbl>
    8 Chirodzo 2016-11-16 00:00:00        12 burntbricks                 2
    9 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
   10 Chirodzo 2016-12-16 00:00:00        12 burntbricks                 3
   23 Ruaca    2016-11-21 00:00:00        10 burntbricks                 3
   24 Ruaca    2016-11-21 00:00:00         6 burntbricks                 2
   25 Ruaca    2016-11-21 00:00:00        11 burntbricks                 2
   26 Ruaca    2016-11-21 00:00:00         3 burntbricks                 2
   27 Ruaca    2016-11-21 00:00:00         7 burntbricks                 3
   28 Ruaca    2016-11-21 00:00:00         2 muddaub                     3
   29 Ruaca    2016-11-21 00:00:00         7 burntbricks                 3
# ℹ 78 more rows

Pipes

What if you want to select and filter at the same time? There are three ways to do this: use intermediate steps, nested functions, or pipes.

With intermediate steps, you create a temporary dataframe and use that as input to the next function, like this:

interviews2 <- filter(interviews, village == "Chirodzo")
interviews_ch <- select(interviews2, village:respondent_wall_type)

This is readable, but can clutter up your workspace with lots of objects that you have to name individually. With multiple steps, that can be hard to keep track of.

You can also nest functions (i.e. one function inside of another), like this:

interviews_ch <- select(filter(interviews, village == "Chirodzo"),
                         village:respondent_wall_type)

This is handy, but can be difficult to read if too many functions are nested, as R evaluates the expression from the inside out (in this case, filtering, then selecting).

The last option, pipes, are a recent addition to R. Pipes let you take the output of one function and send it directly to the next, which is useful when you need to do many things to the same dataset. Pipes in R look like %>% and are made available via the magrittr package, installed automatically with dplyr. If you use RStudio, you can type the pipe with:

Ctrl + Shift + M if you have a PC or Cmd + Shift + M if you have a Mac.

interviews %>%
    filter(village == "Chirodzo") %>%
    select(village:respondent_wall_type)

# A tibble: 39 × 4
   village  interview_date      no_membrs respondent_wall_type
   <chr>    <dttm>                  <dbl> <chr>               
Chirodzo 2016-11-16 00:00:00        12 burntbricks         
Chirodzo 2016-11-16 00:00:00         8 burntbricks         
Chirodzo 2016-12-16 00:00:00        12 burntbricks         
Chirodzo 2016-11-17 00:00:00         8 burntbricks         
Chirodzo 2016-11-17 00:00:00         5 muddaub             
Chirodzo 2016-11-17 00:00:00         6 sunbricks           
Chirodzo 2016-11-17 00:00:00         3 burntbricks         
Chirodzo 2016-11-17 00:00:00         7 muddaub             
Chirodzo 2016-11-17 00:00:00         2 muddaub             
Chirodzo 2016-11-17 00:00:00         9 muddaub             
# ℹ 29 more rows

In the above code, we use the pipe to send the interviews dataset first through filter() to keep rows where village is “Chirodzo”, then through select() to keep only the no_membrs and years_liv columns. Since %>% takes the object on its left and passes it as the first argument to the function on its right, we don’t need to explicitly include the dataframe as an argument to the filter() and select() functions any more.

Some may find it helpful to read the pipe like the word “then”. For instance, in the above example, we take the dataframe interviews, then we filter for rows with village == "Chirodzo", then we select columns no_membrs and years_liv. The dplyr functions by themselves are somewhat simple, but by combining them into linear workflows with the pipe, we can accomplish more complex data wrangling operations.

If we want to create a new object with this smaller version of the data, we can assign it a new name:

interviews_ch <- interviews %>%
    filter(village == "Chirodzo") %>%
    select(village:respondent_wall_type)

interviews_ch

# A tibble: 39 × 4
   village  interview_date      no_membrs respondent_wall_type
   <chr>    <dttm>                  <dbl> <chr>               
Chirodzo 2016-11-16 00:00:00        12 burntbricks         
Chirodzo 2016-11-16 00:00:00         8 burntbricks         
Chirodzo 2016-12-16 00:00:00        12 burntbricks         
Chirodzo 2016-11-17 00:00:00         8 burntbricks         
Chirodzo 2016-11-17 00:00:00         5 muddaub             
Chirodzo 2016-11-17 00:00:00         6 sunbricks           
Chirodzo 2016-11-17 00:00:00         3 burntbricks         
Chirodzo 2016-11-17 00:00:00         7 muddaub             
Chirodzo 2016-11-17 00:00:00         2 muddaub             
Chirodzo 2016-11-17 00:00:00         9 muddaub             
# ℹ 29 more rows

Note that the final dataframe (interviews_ch) is the leftmost part of this expression.

Exercise

Using pipes, subset the interviews data to include interviews where respondents were members of an irrigation association (memb_assoc) and retain only the columns affect_conflicts, liv_count, and no_meals.
Solution
interviews %>%
    filter(memb_assoc == "yes") %>%
    select(affect_conflicts, liv_count, no_meals)
Error in `filter()`:
ℹ In argument: `memb_assoc == "yes"`.
Caused by error:
! object 'memb_assoc' not found

Mutate

Frequently you’ll want to create new columns based on the values in existing columns, for example to do unit conversions, or to find the ratio of values in two columns. For this we’ll use mutate().

We might be interested in the number of meals served in a given household (i.e. number of people times the number of meals served):

interviews %>%
    mutate(people_per_room = no_membrs * no_meals)

# A tibble: 131 × 7
   key_ID village  interview_date      no_membrs respondent_wall_type no_meals
    <dbl> <chr>    <dttm>                  <dbl> <chr>                   <dbl>
 1      1 God      2016-11-17 00:00:00         3 muddaub                     2
 2      1 God      2016-11-17 00:00:00         7 muddaub                     2
 3      3 God      2016-11-17 00:00:00        10 burntbricks                 2
 4      4 God      2016-11-17 00:00:00         7 burntbricks                 2
 5      5 God      2016-11-17 00:00:00         7 burntbricks                 2
 6      6 God      2016-11-17 00:00:00         3 muddaub                     2
 7      7 God      2016-11-17 00:00:00         6 muddaub                     3
 8      8 Chirodzo 2016-11-16 00:00:00        12 burntbricks                 2
 9      9 Chirodzo 2016-11-16 00:00:00         8 burntbricks                 3
10     10 Chirodzo 2016-12-16 00:00:00        12 burntbricks                 3
# ℹ 121 more rows
# ℹ 1 more variable: people_per_room <dbl>

Exercise

Create a new dataframe from the interviews data that meets the following criteria: contains only the village column and a new column called total_meals containing a value that is equal to the total number of meals served in the household per day on average (no_membrs times no_meals). Only the rows where total_meals is greater than 20 should be shown in the final dataframe.

Hint: think about how the commands should be ordered to produce this data frame!
Solution
interviews_total_meals <- interviews %>%
    mutate(total_meals = no_membrs * no_meals) %>%
    filter(total_meals > 20) %>%
    select(village, total_meals)

Split-apply-combine data analysis and the summarize() function

Many data analysis tasks can be approached using the split-apply-combine paradigm: split the data into groups, apply some analysis to each group, and then combine the results. dplyr makes this very easy through the use of the group_by() function.

The `summarize()` function

group_by() is often used together with summarize(), which collapses each group into a single-row summary of that group. group_by() takes as arguments the column names that contain the categorical variables for which you want to calculate the summary statistics. So to compute the average household size by village:

interviews %>%
    group_by(village) %>%
    summarize(mean_no_membrs = mean(no_membrs))

# A tibble: 3 × 2
  village  mean_no_membrs
  <chr>             <dbl>
1 Chirodzo           7.08
2 God                6.86
3 Ruaca              7.57

You may also have noticed that the output from these calls doesn’t run off the screen anymore. It’s one of the advantages of tbl_df over dataframe.

You can also group by multiple columns:

interviews %>%
    group_by(village, respondent_wall_type) %>%
    summarize(mean_no_membrs = mean(no_membrs))

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

# A tibble: 10 × 3
# Groups:   village [3]
   village  respondent_wall_type mean_no_membrs
   <chr>    <chr>                         <dbl>
Chirodzo burntbricks                    8.18
Chirodzo muddaub                        5.62
Chirodzo sunbricks                      6   
God      burntbricks                    7.47
God      muddaub                        5.47
God      sunbricks                      7.89
Ruaca    burntbricks                    7.73
Ruaca    cement                         7   
Ruaca    muddaub                        7   
Ruaca    sunbricks                      8.29

Note that the output is a grouped tibble. To obtain an ungrouped tibble, use the ungroup function:

interviews %>%
    group_by(village, respondent_wall_type) %>%
    summarize(mean_no_membrs = mean(no_membrs)) %>%
    ungroup()

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

# A tibble: 10 × 3
   village  respondent_wall_type mean_no_membrs
   <chr>    <chr>                         <dbl>
Chirodzo burntbricks                    8.18
Chirodzo muddaub                        5.62
Chirodzo sunbricks                      6   
God      burntbricks                    7.47
God      muddaub                        5.47
God      sunbricks                      7.89
Ruaca    burntbricks                    7.73
Ruaca    cement                         7   
Ruaca    muddaub                        7   
Ruaca    sunbricks                      8.29

Once the data are grouped, you can also summarize multiple variables at the same time (and not necessarily on the same variable). For instance, we could add a column indicating the minimum household size for each village for each group (type of wall):

interviews %>%
    group_by(village, respondent_wall_type) %>%
    summarize(mean_no_membrs = mean(no_membrs),
              min_membrs = min(no_membrs))

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

# A tibble: 10 × 4
# Groups:   village [3]
   village  respondent_wall_type mean_no_membrs min_membrs
   <chr>    <chr>                         <dbl>      <dbl>
Chirodzo burntbricks                    8.18          3
Chirodzo muddaub                        5.62          2
Chirodzo sunbricks                      6             6
God      burntbricks                    7.47          3
God      muddaub                        5.47          3
God      sunbricks                      7.89          4
Ruaca    burntbricks                    7.73          3
Ruaca    cement                         7             7
Ruaca    muddaub                        7             2
Ruaca    sunbricks                      8.29          4

It is sometimes useful to rearrange the result of a query to inspect the values. For instance, we can sort on min_membrs to put the group with the smallest household first:

interviews %>%
    group_by(village, respondent_wall_type) %>%
    summarize(mean_no_membrs = mean(no_membrs),
              min_membrs = min(no_membrs)) %>%
    arrange(min_membrs)

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

# A tibble: 10 × 4
# Groups:   village [3]
   village  respondent_wall_type mean_no_membrs min_membrs
   <chr>    <chr>                         <dbl>      <dbl>
Chirodzo muddaub                        5.62          2
Ruaca    muddaub                        7             2
Chirodzo burntbricks                    8.18          3
God      burntbricks                    7.47          3
God      muddaub                        5.47          3
Ruaca    burntbricks                    7.73          3
God      sunbricks                      7.89          4
Ruaca    sunbricks                      8.29          4
Chirodzo sunbricks                      6             6
Ruaca    cement                         7             7

To sort in descending order, we need to add the desc() function. If we want to sort the results by decreasing order of minimum household size:

interviews %>%
    group_by(village, respondent_wall_type) %>%
    summarize(mean_no_membrs = mean(no_membrs),
              min_membrs = min(no_membrs)) %>%
    arrange(desc(min_membrs))

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

# A tibble: 10 × 4
# Groups:   village [3]
   village  respondent_wall_type mean_no_membrs min_membrs
   <chr>    <chr>                         <dbl>      <dbl>
Ruaca    cement                         7             7
Chirodzo sunbricks                      6             6
God      sunbricks                      7.89          4
Ruaca    sunbricks                      8.29          4
Chirodzo burntbricks                    8.18          3
God      burntbricks                    7.47          3
God      muddaub                        5.47          3
Ruaca    burntbricks                    7.73          3
Chirodzo muddaub                        5.62          2
Ruaca    muddaub                        7             2

Counting

When working with data, we often want to know the number of observations found for each factor or combination of factors. For this task, dplyr provides count(). For example, if we wanted to count the number of rows of data for each village, we would do:

interviews %>%
    count(village)

# A tibble: 3 × 2
  village      n
  <chr>    <int>
1 Chirodzo    39
2 God         43
3 Ruaca       49

For convenience, count() provides the sort argument to get results in decreasing order:

interviews %>%
    count(village, sort = TRUE)

# A tibble: 3 × 2
  village      n
  <chr>    <int>
1 Ruaca       49
2 God         43
3 Chirodzo    39

Exercise

How many households in the survey have an average of two meals per day? Three meals per day? Are there any other numbers of meals represented?

Solution

interviews %>%
   count(no_meals)

# A tibble: 2 × 2
  no_meals     n
     <dbl> <int>
1        2    52
2        3    79

Use group_by() and summarize() to find the mean, min, and max number of household members for each village. Also add the number of observations (hint: see ?n).

Solution

interviews %>%
  group_by(village) %>%
  summarize(
      mean_no_membrs = mean(no_membrs),
      min_no_membrs = min(no_membrs),
      max_no_membrs = max(no_membrs),
      n = n()
  )

# A tibble: 3 × 5
  village  mean_no_membrs min_no_membrs max_no_membrs     n
  <chr>             <dbl>         <dbl>         <dbl> <int>
1 Chirodzo           7.08             2            12    39
2 God                6.86             3            15    43
3 Ruaca              7.57             2            19    49

What was the largest household interviewed in each month?

Solution

# if not already included, add month, year, and day columns
library(lubridate) # load lubridate if not already loaded


Attaching package: 'lubridate'

The following objects are masked from 'package:base':

    date, intersect, setdiff, union

interviews %>%
    mutate(month = month(interview_date),
           day = day(interview_date),
           year = year(interview_date)) %>%
    group_by(year, month) %>%
    summarize(max_no_membrs = max(no_membrs))

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

# A tibble: 5 × 3
# Groups:   year [2]
   year month max_no_membrs
  <dbl> <dbl>         <dbl>
1  2016    11            19
2  2016    12            12
3  2017     4            17
4  2017     5            15
5  2017     6            15

Exporting data

Now that you have learned how to use dplyr to extract information from or summarize your raw data, you may want to export these new data sets to share them with your collaborators or for archival.

Similar to the read_csv() function used for reading CSV files into R, there is a write_csv() function that generates CSV files from dataframes.

Before using write_csv(), we are going to create a new folder, data_output, in our working directory that will store this generated dataset. We don’t want to write generated datasets in the same directory as our raw data. It’s good practice to keep them separate. The data folder should only contain the raw, unaltered data, and should be left alone to make sure we don’t delete or modify it. In contrast, our script will generate the contents of the data_output directory, so even if the files it contains are deleted, we can always re-generate them.

Now we can save this dataframe to our data_output directory.

write_csv(interviews, file = "data_output/interviews_plotting.csv")

Key Points

Use the dplyr package to manipulate dataframes.

Use select() to choose variables from a dataframe.

Use filter() to choose data based on values.

Use group_by() and summarize() to work with subsets of data.

Use mutate() to create new variables.

Use the tidyr package to change the layout of dataframes.

Use pivot_wider() to go from long to wide format.

Use pivot_longer() to go from wide to long format.

previous episode

R for absolute beginners

next episode

Data Wrangling with dplyr and tidyr

Overview

Note

What is an R package?

Learning `dplyr` and `tidyr`

Selecting columns and filtering rows

Pipes

Exercise

Solution

Mutate

Exercise

Solution

Split-apply-combine data analysis and the summarize() function

The `summarize()` function

Counting

Exercise

Solution

Solution

Solution

Exporting data

Key Points

previous episode

next episode

previous episode

R for absolute beginners

next episode

Data Wrangling with dplyr and tidyr

Overview

Note

What is an R package?

Learning dplyr and tidyr

Selecting columns and filtering rows

Pipes

Exercise

Solution

Mutate

Exercise

Solution

Split-apply-combine data analysis and the summarize() function

The summarize() function

Counting

Exercise

Solution

Solution

Solution

Exporting data

Key Points

previous episode

next episode

Learning `dplyr` and `tidyr`

The `summarize()` function