knitr::kable(
  iris |> 
    group_by(Species) |>
      slice(which.max(Sepal.Length)) |>
    relocate(Species)
)

3.3 Apply a function to each row of a table

And if you want to calculate a new variable (column) with the maximum value of the length of sepals or petals, we do the following:

rowwise() allows the computation a row-at-a-time.
mutate() will create a new column with the requested computation which is to select the max value from the supplied values from 2 columns. Since we have rowwise() on the previous command this will be done one row at a time. We have to add head() to limit the outpout, otherwise kable will print the complete table.

knitr::kable(
 iris |>
 rowwise() |>
 mutate(Max.Len= max(Sepal.Length,Petal.Length)) |> head()
)

3.4 Obtain the relative frequencies or proportions

What % of cases do we have by species?

I changed the original n variable used in the original formula to N to clarify the difference between the variable and the counting function n().

knitr::kable(
  iris |>
  group_by(Species) |>
  summarise(N = n()) |>
  mutate(freq = N / sum(N))
)

In this case we have 50 flowers (cases or rows) for each species, therefore there is 33% of the sample that corresponds to the setosa lily species, 33% to veriscolor and 33% to virginica.

3.5 Remove duplicate rows

This is a common task in data manipulation, but it is easy to solve with the distinct() function:

(The kable table is not used on this very simple output.)

iris |>
distinct(Species)

     Species
1     setosa
2 versicolor
3  virginica

Result shows that the “Species” variable only has 3 different labels: setosa, virginica and vericolor.

3.6 Change the name of the variables

We often need to shorten variable (column) names, to write code more easily and faster. For example, here we will call the variable “Sepal.Length” “SL” to avoid typing errors with capital letters, periods and English spelling. To rename the columns we can write the following:

The code is modified to change the name of 4 columns:

knitr::kable(
iris |>
rename(SL = Sepal.Length,
       SW = Sepal.Width,
       PL = Petal.Length,
       PW = Petal.Width) |>
head()
)

We see that only the name of the selected columns has changed.

3.7 Select complete cases

Note: The iris dataset is complete without missing values.

How to keep the complete observations? We construct a dummy data set containing missing (or missing, NA) values for the example:

df <- tibble(x = c(1, 2, NA), y = c("a", NA, "b"))
df

# A tibble: 3 × 2
      x y    
  <dbl> <chr>
1     1 a    
2     2 <NA> 
3    NA b    

Note the syntax difference for a number: NA and for a character <NA>. This difference would not be visible in a kable formatted table.

We can use the drop_na() function to remove all cases that contain any form of NA:

df |> drop_na()

# A tibble: 1 × 2
      x y    
  <dbl> <chr>
1     1 a    

We can also specifically remove NA only associated with a specific variable, while preserving others:

df |> drop_na(x)

# A tibble: 2 × 2
      x y    
  <dbl> <chr>
1     1 a    
2     2 <NA> 

You can also use the functions na.omit(), filter(complete.cases(.)) or filter(!is.na(x1)).

Notes:

• na.omit() is not a dplyr function.
• the other 2 suggestions only work with the %>% pipe from the magrittr package. For a technical, detailed explanation see Velásquez (2022) “Understanding the native R pipe |>”, or a saved archive.

3.8 Sum across multiple rows/columns

Let’s create an example data set, imagine 1 is presence and 0 absence (or Yes/NO).

(Note the use of = to “assign” values. While this is correct “R purists” prefer the assignment code <-.)

df=data.frame(
   x1=c(1,0,0,NA,0,1,1,NA,0,1),
   x2=c(1,1,NA,1,1,0,NA,NA,0,1),
   x3=c(0,1,0,1,1,0,NA,NA,0,1))
df

   x1 x2 x3
1   1  1  0
2   0  1  1
3   0 NA  0
4  NA  1  1
5   0  1  1
6   1  0  0
7   1 NA NA
8  NA NA NA
9   0  0  0
10  1  1  1

To perform the sum, imagine that we can replace the NAs with zero (absence of information and absence of the event). To summarize all columns we use summarise_all():

NOTE: as above, the provided code only works with the magrittr pipe %>%. However, based on the above blog link, we can modify the code using a “lambda function” shortcut:

df |>
    (\(x) replace(x, is.na(x), 0))() |>
  summarise(across(everything(), sum))

  x1 x2 x3
1  4  5  4

#    summarise_all(funs(sum)) # funs() has been deprecated

Note: while this exercise was useful to learn how to replace NA with 0, the same result could be obtained in this case with:

# funs() has been deprecated: replace with list()
df |> summarise_all(list(sum), na.rm = TRUE)

  x1 x2 x3
1  4  5  4

To summarize each row:

The original code was:

df %>%
    replace(is.na(.), 0) %>%
    mutate(sum = rowSums(.[1:3]))

To make it work with the new R-base pipe, it is necessary to create a function on the fly (a lambda function with no specific name.) This works but clearly the use of the %>% is much more elegant!

df |> 
   (\(x) replace(x, is.na(x), 0))() |>
  (function(x) { mutate(x, sum = rowSums(x[1:3]))})()

   x1 x2 x3 sum
1   1  1  0   2
2   0  1  1   2
3   0  0  0   0
4   0  1  1   2
5   0  1  1   2
6   1  0  0   1
7   1  0  0   1
8   0  0  0   0
9   0  0  0   0
10  1  1  1   3

3.9 Count the number of cases or rows

This is very important, because when we summarize the data in descriptive statistics we should take into account the number of observations that have been used for this:

I change n for N in the original code to clearly distinguish the variable from the counting function n(). I also change the code to compute the mean for all the relevant columns.

knitr::kable(
iris |>
group_by(Species) |>
summarise(N = n(), 
          meanSL = mean(Sepal.Length),
          meanSW = mean(Sepal.Width), 
          meanPL = mean(Petal.Length),
          meanPW= mean(Petal.Width))
)

You can also use the count function:

iris |>
group_by(Species) |>
count()

# A tibble: 3 × 2
# Groups:   Species [3]
  Species        n
  <fct>      <int>
1 setosa        50
2 versicolor    50
3 virginica     50

3.10 Count the number of cases or unique rows (with NAs)

When we have a data set with NAs we can count the number of cases or unique rows with the n_distinct() function.

We create a dummy data set for the example.

data = data.frame(aa=c(1,2,3,4,NA), bb=c('a', 'b', 'a', 'c', 'c'))
data

  aa bb
1  1  a
2  2  b
3  3  a
4  4  c
5 NA  c

data |>                    
  filter(!is.na(aa)) |>    
  group_by(bb) |>          
  summarise(Unique_Elements = n_distinct(aa)) 

# A tibble: 3 × 2
  bb    Unique_Elements
  <chr>           <int>
1 a                   2
2 b                   1
3 c                   1

For example, here we have selected the cases that do not have NA in the variable “aa” and counted the different cases for the variable “bb”.

Note that the value c in column bb associated with NA in column aa is not counted and not reported.

4 Image Credits

Iris depiction from Rosebrock (2019).