tidyr

lhs %>% rhs

billboard

The "Whitburn" project, https://waxy.org/2008/05/the_whitburn_project/, (downloaded April 2008)

check_pivot_spec(spec, call = caller_env())

# A valid spec spec <- tibble(.name = "a", .value = "b", foo = 1) check_pivot_spec(spec) spec <- tibble(.name = "a") try(check_pivot_spec(spec)) # `.name` and `.value` are forced to be the first two columns spec <- tibble(foo = 1, .value = "b", .name = "a") check_pivot_spec(spec)

chop(data, cols, ..., error_call = current_env()) unchop( data, cols, ..., keep_empty = FALSE, ptype = NULL, error_call = current_env() )

# Chop ---------------------------------------------------------------------- df <- tibble(x = c(1, 1, 1, 2, 2, 3), y = 1:6, z = 6:1) # Note that we get one row of output for each unique combination of # non-chopped variables df |> chop(c(y, z)) # cf nest df |> nest(data = c(y, z)) # Unchop -------------------------------------------------------------------- df <- tibble(x = 1:4, y = list(integer(), 1L, 1:2, 1:3)) df |> unchop(y) df |> unchop(y, keep_empty = TRUE) # unchop will error if the types are not compatible: df <- tibble(x = 1:2, y = list("1", 1:3)) try(df |> unchop(y)) # Unchopping a list-col of data frames must generate a df-col because # unchop leaves the column names unchanged df <- tibble(x = 1:3, y = list(NULL, tibble(x = 1), tibble(y = 1:2))) df |> unchop(y) df |> unchop(y, keep_empty = TRUE)

cms_patient_experience cms_patient_care

cms_patient_experience |> dplyr::distinct(measure_cd, measure_title) cms_patient_experience |> pivot_wider( id_cols = starts_with("org"), names_from = measure_cd, values_from = prf_rate ) cms_patient_care |> pivot_wider( names_from = type, values_from = score ) cms_patient_care |> pivot_wider( names_from = measure_abbr, values_from = score ) cms_patient_care |> pivot_wider( names_from = c(measure_abbr, type), values_from = score )

complete(data, ..., fill = list(), explicit = TRUE)

df <- tibble( group = c(1:2, 1, 2), item_id = c(1:2, 2, 3), item_name = c("a", "a", "b", "b"), value1 = c(1, NA, 3, 4), value2 = 4:7 ) df # Combinations -------------------------------------------------------------- # Generate all possible combinations of `group`, `item_id`, and `item_name` # (whether or not they appear in the data) df |> complete(group, item_id, item_name) # Cross all possible `group` values with the unique pairs of # `(item_id, item_name)` that already exist in the data df |> complete(group, nesting(item_id, item_name)) # Within each `group`, generate all possible combinations of # `item_id` and `item_name` that occur in that group df |> dplyr::group_by(group) |> complete(item_id, item_name) # Supplying values for new rows --------------------------------------------- # Use `fill` to replace NAs with some value. By default, affects both new # (implicit) and pre-existing (explicit) missing values. df |> complete( group, nesting(item_id, item_name), fill = list(value1 = 0, value2 = 99) ) # Limit the fill to only the newly created (i.e. previously implicit) # missing values with `explicit = FALSE` df |> complete( group, nesting(item_id, item_name), fill = list(value1 = 0, value2 = 99), explicit = FALSE )

construction

Completions of "New Residential Construction" found in Table 5 at https://www.census.gov/construction/nrc/xls/newresconst.xls (downloaded March 2019)

complete_(data, cols, fill = list(), ...) drop_na_(data, vars) expand_(data, dots, ...) crossing_(x) nesting_(x) extract_( data, col, into, regex = "([[:alnum:]]+)", remove = TRUE, convert = FALSE, ... ) fill_(data, fill_cols, .direction = c("down", "up")) gather_( data, key_col, value_col, gather_cols, na.rm = FALSE, convert = FALSE, factor_key = FALSE ) nest_(...) separate_rows_(data, cols, sep = "[^[:alnum:].]+", convert = FALSE) separate_( data, col, into, sep = "[^[:alnum:]]+", remove = TRUE, convert = FALSE, extra = "warn", fill = "warn", ... ) spread_( data, key_col, value_col, fill = NA, convert = FALSE, drop = TRUE, sep = NULL ) unite_(data, col, from, sep = "_", remove = TRUE) unnest_(...)

drop_na(data, ...)

df <- tibble(x = c(1, 2, NA), y = c("a", NA, "b")) df |> drop_na() df |> drop_na(x) vars <- "y" df |> drop_na(x, any_of(vars))

expand(data, ..., .name_repair = "check_unique") crossing(..., .name_repair = "check_unique") nesting(..., .name_repair = "check_unique")

# Finding combinations ------------------------------------------------------ fruits <- tibble( type = c("apple", "orange", "apple", "orange", "orange", "orange"), year = c(2010, 2010, 2012, 2010, 2011, 2012), size = factor( c("XS", "S", "M", "S", "S", "M"), levels = c("XS", "S", "M", "L") ), weights = rnorm(6, as.numeric(size) + 2) ) # All combinations, including factor levels that are not used fruits |> expand(type) fruits |> expand(size) fruits |> expand(type, size) fruits |> expand(type, size, year) # Only combinations that already appear in the data fruits |> expand(nesting(type)) fruits |> expand(nesting(size)) fruits |> expand(nesting(type, size)) fruits |> expand(nesting(type, size, year)) # Other uses ---------------------------------------------------------------- # Use with `full_seq()` to fill in values of continuous variables fruits |> expand(type, size, full_seq(year, 1)) fruits |> expand(type, size, 2010:2013) # Use `anti_join()` to determine which observations are missing all <- fruits |> expand(type, size, year) all all |> dplyr::anti_join(fruits) # Use with `right_join()` to fill in missing rows (like `complete()`) fruits |> dplyr::right_join(all) # Use with `group_by()` to expand within each group fruits |> dplyr::group_by(type) |> expand(year, size)

expand_grid(..., .name_repair = "check_unique", .vary = "slowest")

# Default behavior varies the first column "slowest" expand_grid(x = 1:3, y = 1:2) # Vary the first column "fastest", like `expand.grid()` expand_grid(x = 1:3, y = 1:2, .vary = "fastest") # Can also expand data frames expand_grid(df = tibble(x = 1:2, y = c(2, 1)), z = 1:3) # And matrices expand_grid(x1 = matrix(1:4, nrow = 2), x2 = matrix(5:8, nrow = 2))

extract( data, col, into, regex = "([[:alnum:]]+)", remove = TRUE, convert = FALSE, ... )

df <- tibble(x = c(NA, "a-b", "a-d", "b-c", "d-e")) df |> extract(x, "A") df |> extract(x, c("A", "B"), "([[:alnum:]]+)-([[:alnum:]]+)") # Now recommended df |> separate_wider_regex( x, patterns = c(A = "[[:alnum:]]+", "-", B = "[[:alnum:]]+") ) # If no match, NA: df |> extract(x, c("A", "B"), "([a-d]+)-([a-d]+)")

extract_numeric(x)

fill(data, ..., .by = NULL, .direction = c("down", "up", "downup", "updown"))

# direction = "down" -------------------------------------------------------- # Value (year) is recorded only when it changes sales <- tibble::tribble( ~quarter, ~year, ~sales, "Q1", 2000, 66013, "Q2", NA, 69182, "Q3", NA, 53175, "Q4", NA, 21001, "Q1", 2001, 46036, "Q2", NA, 58842, "Q3", NA, 44568, "Q4", NA, 50197, "Q1", 2002, 39113, "Q2", NA, 41668, "Q3", NA, 30144, "Q4", NA, 52897, "Q1", 2004, 32129, "Q2", NA, 67686, "Q3", NA, 31768, "Q4", NA, 49094 ) # `fill()` defaults to replacing missing data from top to bottom sales |> fill(year) # direction = "up" ---------------------------------------------------------- # Value (pet_type) is missing above tidy_pets <- tibble::tribble( ~rank, ~pet_type, ~breed, 1L, NA, "Boston Terrier", 2L, NA, "Retrievers (Labrador)", 3L, NA, "Retrievers (Golden)", 4L, NA, "French Bulldogs", 5L, NA, "Bulldogs", 6L, "Dog", "Beagles", 1L, NA, "Persian", 2L, NA, "Maine Coon", 3L, NA, "Ragdoll", 4L, NA, "Exotic", 5L, NA, "Siamese", 6L, "Cat", "American Short" ) # For values that are missing above you can use `.direction = "up"` tidy_pets |> fill(pet_type, .direction = "up") # direction = "downup" ------------------------------------------------------ # Value (n_squirrels) is missing above and below within a group squirrels <- tibble::tribble( ~group, ~name, ~role, ~n_squirrels, 1, "Sam", "Observer", NA, 1, "Mara", "Scorekeeper", 8, 1, "Jesse", "Observer", NA, 1, "Tom", "Observer", NA, 2, "Mike", "Observer", NA, 2, "Rachael", "Observer", NA, 2, "Sydekea", "Scorekeeper", 14, 2, "Gabriela", "Observer", NA, 3, "Derrick", "Observer", NA, 3, "Kara", "Scorekeeper", 9, 3, "Emily", "Observer", NA, 3, "Danielle", "Observer", NA ) # The values are inconsistently missing by position within the `group`. # Use `.direction = "downup"` to fill missing values in both directions # and `.by = group` to apply the fill per group. squirrels |> fill(n_squirrels, .direction = "downup", .by = group) # If you want, you can also supply a data frame grouped with `group_by()`, # but don't forget to `ungroup()`! squirrels |> dplyr::group_by(group) |> fill(n_squirrels, .direction = "downup") |> dplyr::ungroup()

fish_encounters

Dataset provided by Myfanwy Johnston; more details at https://fishsciences.github.io/post/visualizing-fish-encounter-histories/

full_seq(x, period, tol = 1e-06)

full_seq(c(1, 2, 4, 5, 10), 1)

gather( data, key = "key", value = "value", ..., na.rm = FALSE, convert = FALSE, factor_key = FALSE )

# From https://stackoverflow.com/questions/1181060 stocks <- tibble( time = as.Date("2009-01-01") + 0:9, X = rnorm(10, 0, 1), Y = rnorm(10, 0, 2), Z = rnorm(10, 0, 4) ) gather(stocks, "stock", "price", -time) stocks |> gather("stock", "price", -time) # get first observation for each Species in iris data -- base R mini_iris <- iris[c(1, 51, 101), ] # gather Sepal.Length, Sepal.Width, Petal.Length, Petal.Width gather(mini_iris, key = "flower_att", value = "measurement", Sepal.Length, Sepal.Width, Petal.Length, Petal.Width) # same result but less verbose gather(mini_iris, key = "flower_att", value = "measurement", -Species)

hoist( .data, .col, ..., .remove = TRUE, .simplify = TRUE, .ptype = NULL, .transform = NULL )

df <- tibble( character = c("Toothless", "Dory"), metadata = list( list( species = "dragon", color = "black", films = c( "How to Train Your Dragon", "How to Train Your Dragon 2", "How to Train Your Dragon: The Hidden World" ) ), list( species = "blue tang", color = "blue", films = c("Finding Nemo", "Finding Dory") ) ) ) df # Extract only specified components df |> hoist(metadata, "species", first_film = list("films", 1L), third_film = list("films", 3L) )

household

nest(.data, ..., .by = NULL, .key = NULL, .names_sep = NULL)

df <- tibble(x = c(1, 1, 1, 2, 2, 3), y = 1:6, z = 6:1) # Specify variables to nest using name-variable pairs. # Note that we get one row of output for each unique combination of # non-nested variables. df |> nest(data = c(y, z)) # Specify variables to nest by (rather than variables to nest) using `.by` df |> nest(.by = x) # In this case, since `...` isn't used you can specify the resulting column # name with `.key` df |> nest(.by = x, .key = "cols") # Use tidyselect syntax and helpers, just like in `dplyr::select()` df |> nest(data = any_of(c("y", "z"))) # `...` and `.by` can be used together to drop columns you no longer need, # or to include the columns you are nesting by in the inner data frame too. # This drops `z`: df |> nest(data = y, .by = x) # This includes `x` in the inner data frame: df |> nest(data = everything(), .by = x) # Multiple nesting structures can be specified at once iris |> nest(petal = starts_with("Petal"), sepal = starts_with("Sepal")) iris |> nest(width = contains("Width"), length = contains("Length")) # Nesting a grouped data frame nests all variables apart from the group vars fish_encounters |> dplyr::group_by(fish) |> nest() # That is similar to `nest(.by = )`, except here the result isn't grouped fish_encounters |> nest(.by = fish) # Nesting is often useful for creating per group models mtcars |> nest(.by = cyl) |> dplyr::mutate(models = lapply(data, function(df) lm(mpg ~ wt, data = df)))

nest_legacy(data, ..., .key = "data") unnest_legacy(data, ..., .drop = NA, .id = NULL, .sep = NULL, .preserve = NULL)

# Nest and unnest are inverses df <- tibble(x = c(1, 1, 2), y = 3:1) df |> nest_legacy(y) df |> nest_legacy(y) |> unnest_legacy() # nesting ------------------------------------------------------------------- as_tibble(iris) |> nest_legacy(!Species) as_tibble(chickwts) |> nest_legacy(weight) # unnesting ----------------------------------------------------------------- df <- tibble( x = 1:2, y = list( tibble(z = 1), tibble(z = 3:4) ) ) df |> unnest_legacy(y) # You can also unnest multiple columns simultaneously df <- tibble( a = list(c("a", "b"), "c"), b = list(1:2, 3), c = c(11, 22) ) df |> unnest_legacy(a, b) # If you omit the column names, it'll unnest all list-cols df |> unnest_legacy()

pack(.data, ..., .names_sep = NULL, .error_call = current_env()) unpack( data, cols, ..., names_sep = NULL, names_repair = "check_unique", error_call = current_env() )

# Packing ------------------------------------------------------------------- # It's not currently clear why you would ever want to pack columns # since few functions work with this sort of data. df <- tibble(x1 = 1:3, x2 = 4:6, x3 = 7:9, y = 1:3) df df |> pack(x = starts_with("x")) df |> pack(x = c(x1, x2, x3), y = y) # .names_sep allows you to strip off common prefixes; this # acts as a natural inverse to name_sep in unpack() iris |> as_tibble() |> pack( Sepal = starts_with("Sepal"), Petal = starts_with("Petal"), .names_sep = "." ) # Unpacking ----------------------------------------------------------------- df <- tibble( x = 1:3, y = tibble(a = 1:3, b = 3:1), z = tibble(X = c("a", "b", "c"), Y = runif(3), Z = c(TRUE, FALSE, NA)) ) df df |> unpack(y) df |> unpack(c(y, z)) df |> unpack(c(y, z), names_sep = "_")

pivot_longer( data, cols, ..., cols_vary = "fastest", names_to = "name", names_prefix = NULL, names_sep = NULL, names_pattern = NULL, names_ptypes = NULL, names_transform = NULL, names_repair = "check_unique", values_to = "value", values_drop_na = FALSE, values_ptypes = NULL, values_transform = NULL )

# See vignette("pivot") for examples and explanation # Simplest case where column names are character data relig_income relig_income |> pivot_longer(!religion, names_to = "income", values_to = "count") # Slightly more complex case where columns have common prefix, # and missing missings are structural so should be dropped. billboard billboard |> pivot_longer( cols = starts_with("wk"), names_to = "week", names_prefix = "wk", values_to = "rank", values_drop_na = TRUE ) # Multiple variables stored in column names who |> pivot_longer( cols = new_sp_m014:newrel_f65, names_to = c("diagnosis", "gender", "age"), names_pattern = "new_?(.*)_(.)(.*)", values_to = "count" ) # Multiple observations per row. Since all columns are used in the pivoting # process, we'll use `cols_vary` to keep values from the original columns # close together in the output. anscombe anscombe |> pivot_longer( everything(), cols_vary = "slowest", names_to = c(".value", "set"), names_pattern = "(.)(.)" )

pivot_longer_spec( data, spec, ..., cols_vary = "fastest", names_repair = "check_unique", values_drop_na = FALSE, values_ptypes = NULL, values_transform = NULL, error_call = current_env() ) build_longer_spec( data, cols, ..., names_to = "name", values_to = "value", names_prefix = NULL, names_sep = NULL, names_pattern = NULL, names_ptypes = NULL, names_transform = NULL, error_call = current_env() )

# See vignette("pivot") for examples and explanation # Use `build_longer_spec()` to build `spec` using similar syntax to `pivot_longer()` # and run `pivot_longer_spec()` based on `spec`. spec <- relig_income |> build_longer_spec( cols = !religion, names_to = "income", values_to = "count" ) spec pivot_longer_spec(relig_income, spec) # Is equivalent to: relig_income |> pivot_longer( cols = !religion, names_to = "income", values_to = "count" )

pivot_wider( data, ..., id_cols = NULL, id_expand = FALSE, names_from = name, names_prefix = "", names_sep = "_", names_glue = NULL, names_sort = FALSE, names_vary = "fastest", names_expand = FALSE, names_repair = "check_unique", values_from = value, values_fill = NULL, values_fn = NULL, unused_fn = NULL )

# See vignette("pivot") for examples and explanation fish_encounters fish_encounters |> pivot_wider(names_from = station, values_from = seen) # Fill in missing values fish_encounters |> pivot_wider(names_from = station, values_from = seen, values_fill = 0) # Generate column names from multiple variables us_rent_income us_rent_income |> pivot_wider( names_from = variable, values_from = c(estimate, moe) ) # You can control whether `names_from` values vary fastest or slowest # relative to the `values_from` column names using `names_vary`. us_rent_income |> pivot_wider( names_from = variable, values_from = c(estimate, moe), names_vary = "slowest" ) # When there are multiple `names_from` or `values_from`, you can use # use `names_sep` or `names_glue` to control the output variable names us_rent_income |> pivot_wider( names_from = variable, names_sep = ".", values_from = c(estimate, moe) ) us_rent_income |> pivot_wider( names_from = variable, names_glue = "variable_.value", values_from = c(estimate, moe) ) # Can perform aggregation with `values_fn` warpbreaks <- as_tibble(warpbreaks[c("wool", "tension", "breaks")]) warpbreaks warpbreaks |> pivot_wider( names_from = wool, values_from = breaks, values_fn = mean ) # Can pass an anonymous function to `values_fn` when you # need to supply additional arguments warpbreaks$breaks[1] <- NA warpbreaks |> pivot_wider( names_from = wool, values_from = breaks, values_fn = ~ mean(.x, na.rm = TRUE) )

pivot_wider_spec( data, spec, ..., names_repair = "check_unique", id_cols = NULL, id_expand = FALSE, values_fill = NULL, values_fn = NULL, unused_fn = NULL, error_call = current_env() ) build_wider_spec( data, ..., names_from = name, values_from = value, names_prefix = "", names_sep = "_", names_glue = NULL, names_sort = FALSE, names_vary = "fastest", names_expand = FALSE, error_call = current_env() )

# See vignette("pivot") for examples and explanation us_rent_income spec1 <- us_rent_income |> build_wider_spec(names_from = variable, values_from = c(estimate, moe)) spec1 us_rent_income |> pivot_wider_spec(spec1) # Is equivalent to us_rent_income |> pivot_wider(names_from = variable, values_from = c(estimate, moe)) # `pivot_wider_spec()` provides more control over column names and output format # instead of creating columns with estimate_ and moe_ prefixes, # keep original variable name for estimates and attach _moe as suffix spec2 <- tibble( .name = c("income", "rent", "income_moe", "rent_moe"), .value = c("estimate", "estimate", "moe", "moe"), variable = c("income", "rent", "income", "rent") ) us_rent_income |> pivot_wider_spec(spec2)

relig_income

Downloaded from https://www.pewresearch.org/religious-landscape-study/database/ (downloaded November 2009)

replace_na(data, replace, ...)

# Replace NAs in a data frame df <- tibble(x = c(1, 2, NA), y = c("a", NA, "b")) df |> replace_na(list(x = 0, y = "unknown")) # Replace NAs in a vector df |> dplyr::mutate(x = replace_na(x, 0)) # OR df$x |> replace_na(0) df$y |> replace_na("unknown") # Replace NULLs in a list: NULLs are the list-col equivalent of NAs df_list <- tibble(z = list(1:5, NULL, 10:20)) df_list |> replace_na(list(z = list(5)))

separate( data, col, into, sep = "[^[:alnum:]]+", remove = TRUE, convert = FALSE, extra = "warn", fill = "warn", ... )

# If you want to split by any non-alphanumeric value (the default): df <- tibble(x = c(NA, "x.y", "x.z", "y.z")) df |> separate(x, c("A", "B")) # If you just want the second variable: df |> separate(x, c(NA, "B")) # We now recommend separate_wider_delim() instead: df |> separate_wider_delim(x, ".", names = c("A", "B")) df |> separate_wider_delim(x, ".", names = c(NA, "B")) # Controlling uneven splits ------------------------------------------------- # If every row doesn't split into the same number of pieces, use # the extra and fill arguments to control what happens: df <- tibble(x = c("x", "x y", "x y z", NA)) df |> separate(x, c("a", "b")) # The same behaviour as previous, but drops the c without warnings: df |> separate(x, c("a", "b"), extra = "drop", fill = "right") # Opposite of previous, keeping the c and filling left: df |> separate(x, c("a", "b"), extra = "merge", fill = "left") # Or you can keep all three: df |> separate(x, c("a", "b", "c")) # To only split a specified number of times use extra = "merge": df <- tibble(x = c("x: 123", "y: error: 7")) df |> separate(x, c("key", "value"), ": ", extra = "merge") # Controlling column types -------------------------------------------------- # convert = TRUE detects column classes: df <- tibble(x = c("x:1", "x:2", "y:4", "z", NA)) df |> separate(x, c("key", "value"), ":") |> str() df |> separate(x, c("key", "value"), ":", convert = TRUE) |> str()

separate_longer_delim(data, cols, delim, ...) separate_longer_position(data, cols, width, ..., keep_empty = FALSE)

df <- tibble(id = 1:4, x = c("x", "x y", "x y z", NA)) df |> separate_longer_delim(x, delim = " ") # You can separate multiple columns at once if they have the same structure df <- tibble(id = 1:3, x = c("x", "x y", "x y z"), y = c("a", "a b", "a b c")) df |> separate_longer_delim(c(x, y), delim = " ") # Or instead split by a fixed length df <- tibble(id = 1:3, x = c("ab", "def", "")) df |> separate_longer_position(x, 1) df |> separate_longer_position(x, 2) df |> separate_longer_position(x, 2, keep_empty = TRUE)

separate_rows(data, ..., sep = "[^[:alnum:].]+", convert = FALSE)

df <- tibble( x = 1:3, y = c("a", "d,e,f", "g,h"), z = c("1", "2,3,4", "5,6") ) separate_rows(df, y, z, convert = TRUE) # Now recommended df |> separate_longer_delim(c(y, z), delim = ",")

separate_wider_delim( data, cols, delim, ..., names = NULL, names_sep = NULL, names_repair = "check_unique", too_few = c("error", "debug", "align_start", "align_end"), too_many = c("error", "debug", "drop", "merge"), cols_remove = TRUE ) separate_wider_position( data, cols, widths, ..., names_sep = NULL, names_repair = "check_unique", too_few = c("error", "debug", "align_start"), too_many = c("error", "debug", "drop"), cols_remove = TRUE ) separate_wider_regex( data, cols, patterns, ..., names_sep = NULL, names_repair = "check_unique", too_few = c("error", "debug", "align_start"), cols_remove = TRUE )

df <- tibble(id = 1:3, x = c("m-123", "f-455", "f-123")) # There are three basic ways to split up a string into pieces: # 1. with a delimiter df |> separate_wider_delim(x, delim = "-", names = c("gender", "unit")) # 2. by length df |> separate_wider_position(x, c(gender = 1, 1, unit = 3)) # 3. defining each component with a regular expression df |> separate_wider_regex(x, c(gender = ".", ".", unit = "\\\+")) # Sometimes you split on the "last" delimiter df <- tibble(var = c("race_1", "race_2", "age_bucket_1", "age_bucket_2")) # _delim won't help because it always splits on the first delimiter try(df |> separate_wider_delim(var, "_", names = c("var1", "var2"))) df |> separate_wider_delim(var, "_", names = c("var1", "var2"), too_many = "merge") # Instead, you can use _regex df |> separate_wider_regex(var, c(var1 = ".*", "_", var2 = ".*")) # this works because * is greedy; you can mimic the _delim behaviour with .*? df |> separate_wider_regex(var, c(var1 = ".*?", "_", var2 = ".*")) # If the number of components varies, it's most natural to split into rows df <- tibble(id = 1:4, x = c("x", "x y", "x y z", NA)) df |> separate_longer_delim(x, delim = " ") # But separate_wider_delim() provides some tools to deal with the problem # The default behaviour tells you that there's a problem try(df |> separate_wider_delim(x, delim = " ", names = c("a", "b"))) # You can get additional insight by using the debug options df |> separate_wider_delim( x, delim = " ", names = c("a", "b"), too_few = "debug", too_many = "debug" ) # But you can suppress the warnings df |> separate_wider_delim( x, delim = " ", names = c("a", "b"), too_few = "align_start", too_many = "merge" ) # Or choose to automatically name the columns, producing as many as needed df |> separate_wider_delim(x, delim = " ", names_sep = "", too_few = "align_start")

smiths

spread(data, key, value, fill = NA, convert = FALSE, drop = TRUE, sep = NULL)

stocks <- tibble( time = as.Date("2009-01-01") + 0:9, X = rnorm(10, 0, 1), Y = rnorm(10, 0, 2), Z = rnorm(10, 0, 4) ) stocksm <- stocks |> gather(stock, price, -time) stocksm |> spread(stock, price) stocksm |> spread(time, price) # Spread and gather are complements df <- tibble(x = c("a", "b"), y = c(3, 4), z = c(5, 6)) df |> spread(x, y) |> gather("x", "y", a:b, na.rm = TRUE) # Use 'convert = TRUE' to produce variables of mixed type df <- tibble( row = rep(c(1, 51), each = 3), var = rep(c("Sepal.Length", "Species", "Species_num"), 2), value = c(5.1, "setosa", 1, 7.0, "versicolor", 2) ) df |> spread(var, value) |> str() df |> spread(var, value, convert = TRUE) |> str()

table1 table2 table3 table4a table4b table5

https://www.who.int/teams/global-tuberculosis-programme/data

tidyr_legacy(nms, prefix = "V", sep = "")

df <- tibble(x = 1:2, y = list(tibble(x = 3:5), tibble(x = 4:7))) # Doesn't work because it would produce a data frame with two # columns called x unnest(df, y) # The new tidyverse standard: unnest(df, y, names_repair = "universal") # The old tidyr approach unnest(df, y, names_repair = tidyr_legacy)

uncount(data, weights, ..., .remove = TRUE, .id = NULL)

df <- tibble(x = c("a", "b"), n = c(1, 2)) uncount(df, n) uncount(df, n, .id = "id") # You can also use constants uncount(df, 2) # Or expressions uncount(df, 2 / n)

unite(data, col, ..., sep = "_", remove = TRUE, na.rm = FALSE)

df <- expand_grid(x = c("a", NA), y = c("b", NA)) df df |> unite("z", x:y, remove = FALSE) # To remove missing values: df |> unite("z", x:y, na.rm = TRUE, remove = FALSE) # Separate is almost the complement of unite df |> unite("xy", x:y) |> separate(xy, c("x", "y")) # (but note `x` and `y` contain now "NA" not NA)

unnest( data, cols, ..., keep_empty = FALSE, ptype = NULL, names_sep = NULL, names_repair = "check_unique", .drop = deprecated(), .id = deprecated(), .sep = deprecated(), .preserve = deprecated() )

# unnest() is designed to work with lists of data frames df <- tibble( x = 1:3, y = list( NULL, tibble(a = 1, b = 2), tibble(a = 1:3, b = 3:1, c = 4) ) ) # unnest() recycles input rows for each row of the list-column # and adds a column for each column df |> unnest(y) # input rows with 0 rows in the list-column will usually disappear, # but you can keep them (generating NAs) with keep_empty = TRUE: df |> unnest(y, keep_empty = TRUE) # Multiple columns ---------------------------------------------------------- # You can unnest multiple columns simultaneously df <- tibble( x = 1:2, y = list( tibble(a = 1, b = 2), tibble(a = 3:4, b = 5:6) ), z = list( tibble(c = 1, d = 2), tibble(c = 3:4, d = 5:6) ) ) df |> unnest(c(y, z)) # Compare with unnesting one column at a time, which generates # the Cartesian product df |> unnest(y) |> unnest(z)

unnest_auto(data, col)

unnest_longer( data, col, values_to = NULL, indices_to = NULL, indices_include = NULL, keep_empty = FALSE, names_repair = "check_unique", simplify = TRUE, ptype = NULL, transform = NULL )

# `unnest_longer()` is useful when each component of the list should # form a row df <- tibble( x = 1:4, y = list(NULL, 1:3, 4:5, integer()) ) df |> unnest_longer(y) # Note that empty values like `NULL` and `integer()` are dropped by # default. If you'd like to keep them, set `keep_empty = TRUE`. df |> unnest_longer(y, keep_empty = TRUE) # If the inner vectors are named, the names are copied to an `_id` column df <- tibble( x = 1:2, y = list(c(a = 1, b = 2), c(a = 10, b = 11, c = 12)) ) df |> unnest_longer(y) # Multiple columns ---------------------------------------------------------- # If columns are aligned, you can unnest simultaneously df <- tibble( x = 1:2, y = list(1:2, 3:4), z = list(5:6, 7:8) ) df |> unnest_longer(c(y, z)) # This is important because sequential unnesting would generate the # Cartesian product of the rows df |> unnest_longer(y) |> unnest_longer(z)

unnest_wider( data, col, names_sep = NULL, simplify = TRUE, strict = FALSE, names_repair = "check_unique", ptype = NULL, transform = NULL )

df <- tibble( character = c("Toothless", "Dory"), metadata = list( list( species = "dragon", color = "black", films = c( "How to Train Your Dragon", "How to Train Your Dragon 2", "How to Train Your Dragon: The Hidden World" ) ), list( species = "blue tang", color = "blue", films = c("Finding Nemo", "Finding Dory") ) ) ) df # Turn all components of metadata into columns df |> unnest_wider(metadata) # Choose not to simplify list-cols of length-1 elements df |> unnest_wider(metadata, simplify = FALSE) df |> unnest_wider(metadata, simplify = list(color = FALSE)) # You can also widen unnamed list-cols: df <- tibble( x = 1:3, y = list(NULL, 1:3, 4:5) ) # but you must supply `names_sep` to do so, which generates automatic names: df |> unnest_wider(y, names_sep = "_") # 0-length elements --------------------------------------------------------- # The defaults of `unnest_wider()` treat empty types (like `list()`) as `NULL`. json <- list( list(x = 1:2, y = 1:2), list(x = list(), y = 3:4), list(x = 3L, y = list()) ) df <- tibble(json = json) df |> unnest_wider(json) # To instead enforce strict vctrs typing rules, use `strict` df |> unnest_wider(json, strict = TRUE)

us_rent_income

who who2 population

https://www.who.int/teams/global-tuberculosis-programme/data

world_bank_pop

Dataset from the World Bank data bank: https://data.worldbank.org