使用 purrr 迭代替换数据框列中的字符串

Question

I would like to use purrr to iteratively run several string replacements on a dataframe column with the gsub() function.

This is the example dataframe:

df <- data.frame(Year = "2019",
                 Text = c(rep("a aa", 5), 
                          rep("a bb", 3), 
                          rep("a cc", 2)))

> df
   Year Text
1  2019 a aa
2  2019 a aa
3  2019 a aa
4  2019 a aa
5  2019 a aa
6  2019 a bb
7  2019 a bb
8  2019 a bb
9  2019 a cc
10 2019 a cc

This is how I would normally run the string replacement, and the desired result.

df$Text <- gsub("aa", "One", df$Text, fixed = T)
df$Text <- gsub("bb", "Two", df$Text, fixed = T)
df$Text <- gsub("cc", "Three", df$Text, fixed = T)

> df
   Year    Text
1  2019   a One
2  2019   a One
3  2019   a One
4  2019   a One
5  2019   a One
6  2019   a Two
7  2019   a Two
8  2019   a Two
9  2019 a Three
10 2019 a Three

However this is unrealistic to use as the list of string replacements grows, so I tried to use purrr to iterate such changes using a list of patterns and replacements but I've only managed to produce error messages. I expect the code to iterate through text_pattern and text_replacement and run gsub on df$Text for each pair of pattern/replacement. The example is below along with the error messages.

text_pattern <- c("aa", "bb", "cc")
text_replacement <- c("One", "Two", "Three")

walk2(text_pattern, text_replacement, function(...){
  gsub(text_pattern, text_replacement, df$Text, fixed = F)
  }
)

Warning messages:
1: In gsub(text_former, text_replace, df$Text, fixed = F) :
  argument 'pattern' has length > 1 and only the first element will be used
2: In gsub(text_former, text_replace, df$Text, fixed = F) :
  argument 'replacement' has length > 1 and only the first element will be used
3: In gsub(text_former, text_replace, df$Text, fixed = F) :
  argument 'pattern' has length > 1 and only the first element will be used
4: In gsub(text_former, text_replace, df$Text, fixed = F) :
  argument 'replacement' has length > 1 and only the first element will be used
5: In gsub(text_former, text_replace, df$Text, fixed = F) :
  argument 'pattern' has length > 1 and only the first element will be used
6: In gsub(text_former, text_replace, df$Text, fixed = F) :
  argument 'replacement' has length > 1 and only the first element will be used

Is it possible to accomplish this using functions from purrr ? Or alternatively am I trying to use the wrong tool and is there a different function I should be using?

Answer 1

We can use reduce2

library(purrr)
library(stringr)
df$Text <- reduce2(text_pattern, text_replacement, ~ str_replace(..1, ..2, ..3), 
           .init = df$Text)
df$Text
#[1] "a One"   "a One"   "a One"   "a One"   "a One"   "a Two"   "a Two"   "a Two"   "a Three" "a Three"

---

Or without using anonymous function call

reduce2(text_pattern, text_replacement, .init = df$Text, str_replace)

Answer 2

@akrun's answer is great, however there are a few intermediate points you may also find useful in understanding purrr better.

1. walk2 won't return output, it just returns the first input vector.

   From the docs :

   walk() calls .f for its side-effect and returns the input .x.

   The closest analog for what you're doing is map2 , but see below for why that's also not quite what you need.

2. Arguments inside purrr functions like map and walk refer to generic representations of the vectors being iterated over.

   You have a couple of options for how to refer to input vectors. One is to name the arguments in function(...) . For example, with function(x, y) then this will produce error-free output:

    map2(text_pattern, text_replacement, function(x, y){ gsub(x, y, df$Text, fixed = F) } ) # switching to map2() because walk2 gives silent output

   You can also use ~ syntax and then refer to the input iterables as .x and .y :

    map2(text_pattern, text_replacement, ~gsub(.x, .y, df$Text, fixed = F))

3. The output isn't what you are expecting.

   purrr methods like map and walk loop over the entire vector for each pattern. The output for both of the code snippets in 2. is the following:

    [[1]] [1] "a One" "a One" "a One" "a One" "a One" "a bb" "a bb" "a bb" "a cc" "a cc" [[2]] [1] "a aa" "a aa" "a aa" "a aa" "a aa" "a Two" "a Two" "a Two" "a cc" "a cc" [[3]] [1] "a aa" "a aa" "a aa" "a aa" "a aa" "a bb" "a bb" "a bb" [9] "a Three" "a Three"

   So even fixing the syntax, you're still getting a three-element list, the contents of each element being the results of the replacement operation for each pair of text_pattern - text_replacement . There's still a smush operation that needs to happen to bring them all together with just the replaced elements. That's what @akrun's shift to reduce2 accomplishes.

   One additional note on reduce syntax - the arguments ..1 , ..2 , ..3 refer to the inputs on each iteration, and the use of .init makes the first argument ( ..1 ) equal to df$Text . ..2 and ..3 are what, in the earlier examples of map2 , were .x and .y , respectively (ie pattern and replacement values). See the reduce docs for more.