将 data.frame 列名称传递给函数

Question

我正在尝试编写一个函数来接受 data.frame (x) 和其中的 column 。该函数对 x 执行一些计算，然后返回另一个 data.frame。我坚持使用最佳实践方法将列名称传递给函数。

下面的两个最小示例 fun1 和 fun2 产生了所需的结果，能够使用 max( ） 为例。然而，两者都依赖于看似（至少对我来说）不优雅的

1. substitute() 调用，并且可能依赖于 eval()
2. 将列名作为字符向量传递的需要。

fun1 <- function(x, column){
  do.call("max", list(substitute(x[a], list(a = column))))
}

fun2 <- function(x, column){
  max(eval((substitute(x[a], list(a = column)))))
}

df <- data.frame(B = rnorm(10))
fun1(df, "B")
fun2(df, "B")

例如，我希望能够将该函数调用为 fun(df, B)。我考虑过但没有尝试过的其他选项：

• 将 column 作为列号的整数传递。我认为这会避免 substitute()。理想情况下，该函数可以接受其中任何一个。
• with(x, get(column))，但是，即使它有效，我认为这仍然需要substitute
• 利用formula() 和 match.call()，我对这两个都没有太多经验。

子问题：do.call() 是否优于 eval()？

Answer 1

这个答案将涵盖许多与现有答案相同的元素，但是这个问题（将列名称传递给函数）经常出现，我希望有一个答案能够更全面地涵盖一些内容。

假设我们有一个非常简单的数据框：

dat <- data.frame(x = 1:4,
                  y = 5:8)

我们想编写一个函数来创建一个新列 z，它是列 x 和 y 的总和。

这里一个非常常见的障碍是，自然（但不正确）的尝试通常如下所示：

foo <- function(df,col_name,col1,col2){
      df$col_name <- df$col1 + df$col2
      df
}

#Call foo() like this:    
foo(dat,z,x,y)

这里的问题是 df$col1 不计算表达式 col1。它只是在 df 中查找字面上名为 col1 的列。此行为在“递归（类似列表）对象”部分下的 ?Extract 中进行了描述。

最简单且最常推荐的解决方案是简单地从 $ 切换到 [[ 并将函数参数作为字符串传递：

new_column1 <- function(df,col_name,col1,col2){
    #Create new column col_name as sum of col1 and col2
    df[[col_name]] <- df[[col1]] + df[[col2]]
    df
}

> new_column1(dat,"z","x","y")
  x y  z
1 1 5  6
2 2 6  8
3 3 7 10
4 4 8 12

这通常被认为是“最佳实践”，因为它是最难搞砸的方法。将列名作为字符串传递是尽可能明确的。

以下两个选项更高级。许多流行的软件包都使用这些类型的技术，但使用它们需要更多的小心和技巧，因为它们可能会引入微妙的复杂性和意外的故障点。 Hadley 的《高级 R》一书中的这部分是一个很好的参考资料对于其中一些问题。

如果您确实希望避免用户输入所有这些引号，一种选择可能是使用deparse(substitute())将裸露的、不带引号的列名转换为字符串

new_column2 <- function(df,col_name,col1,col2){
    col_name <- deparse(substitute(col_name))
    col1 <- deparse(substitute(col1))
    col2 <- deparse(substitute(col2))

    df[[col_name]] <- df[[col1]] + df[[col2]]
    df
}

> new_column2(dat,z,x,y)
  x y  z
1 1 5  6
2 2 6  8
3 3 7 10
4 4 8 12

：坦率地说，这可能有点愚蠢，因为我们实际上在做与 new_column1 中相同的事情，只是做了一堆额外的工作将裸名称转换为字符串。

最后，如果我们想要变得真正，我们可能会决定不传递要添加的两列的名称，而是希望更加灵活并允许两个变量的其他组合。在这种情况下，我们可能会在涉及两列的表达式上使用 eval()：

new_column3 <- function(df,col_name,expr){
    col_name <- deparse(substitute(col_name))
    df[[col_name]] <- eval(substitute(expr),df,parent.frame())
    df
}

只是为了好玩，我仍在使用 deparse(substitute())作为新列的名称。在这里，以下所有内容都将起作用：

> new_column3(dat,z,x+y)
  x y  z
1 1 5  6
2 2 6  8
3 3 7 10
4 4 8 12
> new_column3(dat,z,x-y)
  x y  z
1 1 5 -4
2 2 6 -4
3 3 7 -4
4 4 8 -4
> new_column3(dat,z,x*y)
  x y  z
1 1 5  5
2 2 6 12
3 3 7 21
4 4 8 32

因此简短的答案基本上是：将 data.frame 列名称作为字符串传递并使用 [[ 选择单个列。只有当您真正知道自己在做什么时，才开始深入研究eval、substitute等。

Answer 2

您可以直接使用列名称：

df <- data.frame(A=1:10, B=2:11, C=3:12)
fun1 <- function(x, column){
  max(x[,column])
}
fun1(df, "B")
fun1(df, c("B","A"))

无需使用 Replace、eval 等。

您甚至可以将所需的函数作为参数传递：

fun1 <- function(x, column, fn) {
  fn(x[,column])
}
fun1(df, "B", max)

或者，使用 [[ 也适用于选择单个列一次：

df <- data.frame(A=1:10, B=2:11, C=3:12)
fun1 <- function(x, column){
  max(x[[column]])
}
fun1(df, "B")

Answer 3

我个人认为将列作为字符串传递是非常难看的。我喜欢做类似的事情：

get.max <- function(column,data=NULL){
    column<-eval(substitute(column),data, parent.frame())
    max(column)
}

这将产生：

> get.max(mpg,mtcars)
[1] 33.9
> get.max(c(1,2,3,4,5))
[1] 5

注意 data.frame 的规范是可选的。您甚至可以使用列的函数：

> get.max(1/mpg,mtcars)
[1] 0.09615385

Answer 4

借助 dplyr，现在只需在函数体内所需的列名称周围使用双大括号 {{...}} 即可访问数据帧的特定列，例如 col_name：

library(tidyverse)

fun <- function(df, col_name){
   df %>% 
     filter({{col_name}} == "test_string")
} 

Answer 5

另一种方法是使用整洁评估方法。将数据帧的列作为字符串或裸列名称传递非常简单。 此处了解有关 tidyeval 的更多信息。

library(rlang)
library(tidyverse)

set.seed(123)
df <- data.frame(B = rnorm(10), D = rnorm(10))

使用列名称作为字符串

fun3 <- function(x, ...) {
  # capture strings and create variables
  dots <- ensyms(...)
  # unquote to evaluate inside dplyr verbs
  summarise_at(x, vars(!!!dots), list(~ max(., na.rm = TRUE)))
}

fun3(df, "B")
#>          B
#> 1 1.715065

fun3(df, "B", "D")
#>          B        D
#> 1 1.715065 1.786913

使用裸列名称

fun4 <- function(x, ...) {
  # capture expressions and create quosures
  dots <- enquos(...)
  # unquote to evaluate inside dplyr verbs
  summarise_at(x, vars(!!!dots), list(~ max(., na.rm = TRUE)))
}

fun4(df, B)
#>          B
#> 1 1.715065

fun4(df, B, D)
#>          B        D
#> 1 1.715065 1.786913
#>

^{由 reprex 包于 2019 年 3 月 1 日创建（v0 .2.1.9000)}

Answer 6

Tung 的回答和mgrund 的回答< /a> 提出了整洁的评估。在这个答案中，我将展示如何使用这些概念来完成类似于 joran 的答案 的事情（特别是他的函数 new_column3）。这样做的目的是为了更容易地看到基本评估和 tidy 评估之间的差异，以及查看 tidy 评估中可以使用的不同语法。为此，您将需要 rlang 和 dplyr。

使用基本评估工具（joran 的答案）：

new_column3 <- function(df,col_name,expr){
  col_name <- deparse(substitute(col_name))
  df[[col_name]] <- eval(substitute(expr),df,parent.frame())
  df
}

在第一行中，substitute 使我们将 col_name 评估为表达式，更具体地说是一个符号（有时也称为名称），不是一个物体。 rlang 的替代品可以是：

• ensym - 将其转换为符号；
• enexpr - 将其转换为表达式；
• enquo - 将其转换为 quosure，一个表达式，它还指向 R 应该查找变量以对其求值的环境。

大多数时候，您希望拥有指向环境的指针。当您不是特别需要它时，拥有它很少会引起问题。因此，大多数时候您可以使用enquo。在这种情况下，您可以使用 ensym 使代码更易于阅读，因为它可以更清楚地说明 col_name 是什么。

同样在第一行中，deparse 将表达式/符号转换为字符串。您还可以使用 as.character 或 rlang::as_string。

在第二行中，substitute 将 expr 转换为“完整”表达式（不是符号），因此 ensym 不再是一个选项。

同样在第二行中，我们现在可以将 eval 更改为 rlang::eval_tidy。 Eval 仍然可以与 enexpr 一起使用，但不能与 quosure 一起使用。当您有定论时，您不需要将环境传递给评估函数（就像 joran 对 parent.frame() 所做的那样）。

上面建议的替换的一种组合可能是：

new_column3 <- function(df,col_name,expr){
  col_name <- as_string(ensym(col_name))
  df[[col_name]] <- eval_tidy(enquo(expr), df)
  df
}

我们还可以使用 dplyr 运算符，它允许数据屏蔽（将数据框中的列评估为变量，通过其名称调用它）。我们可以改变将符号转换为字符+取子集df的方法，使用[[和mutate：

new_column3 <- function(df,col_name,expr){
  col_name <- ensym(col_name)
  df %>% mutate(!!col_name := eval_tidy(enquo(expr), df))
}

以避免新列被命名为“ col_name”，我们使用 bang-bang !! 运算符对其进行焦急求值（与 R 的默认值惰性求值相反）。因为我们对左侧进行了操作，所以我们不能使用“正常”=，而必须使用新语法:=。

将列名转换为符号，然后用 bang-bang 对其求值的常见操作有一个快捷方式：curly-curly {{ 运算符：

new_column3 <- function(df,col_name,expr){
  df %>% mutate({{col_name}} := eval_tidy(enquo(expr), df))
}

我不是 R 求值专家并且可能过度简化，或者使用了错误的术语，所以请在评论中纠正我。我希望能够帮助比较这个问题的答案中使用的不同工具。

Answer 7

作为一个额外的想法，如果需要将不带引号的列名传递给自定义函数，也许 match.call() 在这种情况下也很有用，作为 deparse( 的替代方案) Replace())：

df <- data.frame(A = 1:10, B = 2:11)

fun <- function(x, column){
  arg <- match.call()
  max(x[[arg$column]])
}

fun(df, A)
#> [1] 10

fun(df, B)
#> [1] 11

如果列名称中存在拼写错误，则更安全的做法是停止并显示错误：

fun <- function(x, column) max(x[[match.call()$column]])
fun(df, typo)
#> Warning in max(x[[match.call()$column]]): no non-missing arguments to max;
#> returning -Inf
#> [1] -Inf

# Stop with error in case of typo
fun <- function(x, column){
  arg <- match.call()
  if (is.null(x[[arg$column]])) stop("Wrong column name")
  max(x[[arg$column]])
}

fun(df, typo)
#> Error in fun(df, typo): Wrong column name
fun(df, A)
#> [1] 10

^{由 reprex 包 (v0.2.1)}

我认为我不会使用这种方法，因为除了传递引用的列之外还有额外的输入和复杂性正如上面答案中指出的那样，但是，这是一种方法。

Answer 8

如果您尝试在 R 包中构建此函数或只是想降低复杂性，则可以执行以下操作：

test_func <- function(df, column) {
  if (column %in% colnames(df)) {
    return(max(df[, column, with=FALSE])) 
  } else {
    stop(cat(column, "not in data.frame columns."))
  }
}

参数 with=FALSE “禁用引用列的能力，就好像它们是变量一样，从而恢复“data.frame 模式”（根据 CRAN 文档）。if 语句是一种快速捕获提供的列名是否在 data.frame 内的方法。还可以在此处使用 tryCatch 错误处理。