Tidyverse Packages

Tidyverse Packages in detail

When working with Data Science in R, the Tidyverse packages are your ultimate toolkit! These packages were designed specifically for Data Science and share a unified design philosophy.

The Tidyverse packages cover the entire data science workflow, from data import and tidying to transformation and visualization. For example, readr is used for data importing, tibble and tidyr for tidying, dplyr and stringr for transformation, and ggplot2 for visualization.

What Are the Tidyverse Packages in R?

Core Tidyverse Packages

There are eight core Tidyverse packages: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, and forcats. These are automatically loaded when you use the command:

install.packages("tidyverse")

Specialized Packages

In addition to the core packages, the Tidyverse also includes specialized packages like DBI for databases, httr for web APIs, and rvest for web scraping. These need to be loaded individually.

Now, let’s explore the core Tidyverse packages and their uses.

Data Visualization and Exploration

1. ggplot2: ggplot2 is a powerful data visualization library based on the “Grammar of Graphics.” It allows you to create visualizations like bar charts, scatter plots, and histograms using a high-level API. Once you define the mapping of variables to aesthetics, ggplot2 takes care of the rest.

To install ggplot2:

install.packages("ggplot2")

Or use the development version:

devtools::install_github("tidyverse/ggplot2")

Example:

# Load the library
library(ggplot2)

# Create a dataframe with categories and values
data <- data.frame(
  Category = c('X', 'Y', 'Z', 'W'),
  Value = c(10, 20, 15, 25)
)

# Create a bar plot
ggplot(data, aes(x = Category, y = Value, fill = Category)) +
  geom_bar(stat = "identity")

Output: A bar plot with default colors for the bars based on categories.

Data Wrangling and Transformation

1. dplyr: dplyr is a widely-used library for data manipulation. Its key functions, often used with group_by(), include:

mutate(): Adds new variables.
select(): Selects specific columns.
filter(): Filters rows based on conditions.
summarise(): Aggregates data.
arrange(): Sorts rows.

To install dplyr:

install.packages("dplyr")

Or use the development version:

devtools::install_github("tidyverse/dplyr")

Example: Filtering Rows

library(dplyr)

# Using the built-in mtcars dataset
mtcars %>% filter(cyl == 6)

Output: Displays rows of the mtcars dataset where the number of cylinders is 6.

2. tidyr: tidyr helps tidy your data, ensuring each variable has its own column and each observation its own row.

Key functions include:

Pivoting: Reshaping data between wide and long formats.
Nesting: Grouping data into nested structures.
Splitting/Combining: Working with character columns.

To install tidyr:

install.packages("tidyr")

Or use the development version:

devtools::install_github("tidyverse/tidyr")

Example: Reshaping Data with pivot_longer()

library(tidyr)

# Create a data frame
data <- data.frame(
  ID = 1:5,
  Score1 = c(80, 90, 85, 88, 92),
  Score2 = c(75, 85, 82, 89, 95)
)

# Convert wide format to long format
long_data <- data %>%
  pivot_longer(cols = starts_with("Score"),
               names_to = "Score_Type",
               values_to = "Value")

print(long_data)

Output:

ID Score_Type Value
1  1    Score1    80
2  1    Score2    75
3  2    Score1    90
4  2    Score2    85
...

3. stringr: stringr simplifies string manipulation in R, offering consistent naming conventions. Functions include:

str_detect(): Detect patterns.
str_extract(): Extract patterns.
str_replace(): Replace patterns.
str_length(): Compute string length.

To install stringr:

install.packages("stringr")

Example: Calculating String Length

library(stringr)

# Calculate string length
length <- str_length("Tidyverse")
print(length)

Output:

4. Forcats: The forcats library in R is designed to address common challenges associated with working with categorical variables, often referred to as factors. Factors are variables with a fixed set of possible values, which are predefined. forcats helps with tasks like reordering levels, modifying the order of values, and other related operations.

Some key functions in forcats include:

fct_relevel(): Reorders factor levels manually.
fct_reorder(): Reorders a factor based on another variable.
fct_infreq(): Reorders a factor by frequency of values.

To install forcats, the recommended approach is to install the tidyverse package:

install.packages("tidyverse")

Alternatively, you can install forcats directly:

install.packages("forcats")

To install the development version from GitHub, use:

devtools::install_github("tidyverse/forcats")

Example:

library(forcats)
library(dplyr)
library(ggplot2)

# Example data: species counts
print(head(starwars %>%
             filter(!is.na(species)) %>%
             count(species, sort = TRUE)))

Output:

# A tibble: 6 × 2
  species      n
  <chr>    <int>
1 Human       35
2 Droid        6
3 Gungan       3
4 Kaminoan     2
5 Mirialan     2
6 Twi'lek      2

Data Import and Management in Tidyverse in R

1. Readr: The readr library offers an efficient way to import rectangular data formats such as .csv, .tsv, .delim, and others. It automatically parses and converts columns into appropriate data types, making data import easier and faster.

Common functions include:

read_csv(): Reads comma-separated files.
read_tsv(): Reads tab-separated files.
read_table(): Reads tabular data.
read_fwf(): Reads fixed-width files.
read_delim(): Reads delimited files.
read_log(): Reads log files.

To install readr, use:

install.packages("tidyverse")  # Recommended
install.packages("readr")      # Alternatively

For the development version:

devtools::install_github("tidyverse/readr")

Example:

library(readr)

# Read a tab-separated file
data <- read_tsv("sample_data.txt", col_names = FALSE)
print(data)

Output:

# A tibble: 1 × 1
  X1
  <chr>
1 A platform for data enthusiasts.

2. Tibble: A tibble is an enhanced version of a data frame in R. Unlike traditional data frames, tibbles do not modify variable names or types and provide better error handling. This makes the code cleaner and more robust. Tibbles are especially useful for large datasets with complex objects.

Key functions:

tibble(): Creates a tibble from column vectors.
tribble(): Creates a tibble row by row.

To install tibble:

install.packages("tidyverse")  # Recommended
install.packages("tibble")     # Alternatively

Development version:

devtools::install_github("tidyverse/tibble")

Example:

library(tibble)

# Create a tibble
data <- tibble(a = 1:3, b = letters[1:3], c = Sys.Date() - 1:3)
print(data)

Output:

# A tibble: 3 × 3
      a b     c
  <int> <chr> <date>
1     1 a     2025-01-22
2     2 b     2025-01-21
3     3 c     2025-01-20

Functional Programming in Tidyverse in R

Purrr: The purrr package provides tools for functional programming in R, particularly with functions and vectors. It simplifies complex operations by replacing repetitive for loops with clean, readable, and type-stable code.

One of its most popular functions is map(), which applies a function to each element of a list or vector.

To install purrr:

install.packages("tidyverse")  # Recommended
install.packages("purrr")      # Alternatively

Development version:

devtools::install_github("tidyverse/purrr")

Example:

library(purrr)

# Example: Model fitting and extracting R-squared
mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map_dbl("r.squared")

Output:

4         6         8
0.5086326 0.4645102 0.4229655