149

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

以下两个最小示例fun1产生fun2了所需的结果，能够对 执行操作x$column，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()and match.call()，这两个我都没有太多经验。

子问题：是do.call()首选eval()吗？

4

7 回答 7

130

您可以直接使用列名：

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"))

无需使用替代、评估等。

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

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

或者， using[[也适用于一次选择一列：

df <- data.frame(A=1:10, B=2:11, C=3:12)
fun1 <- function(x, column){
  max(x[[column]])
}
fun1(df, "B")
于 2010-04-14T23:09:42.887 回答
118

这个答案将涵盖许多与现有答案相同的元素，但是这个问题（将列名传递给函数）经常出现，以至于我希望有一个更全面地涵盖事物的答案。

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

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

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

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

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“递归（类似列表）对象”部分中进行了描述。

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

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 的 Advanced 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

坦率地说，这可能有点傻，因为我们确实在做与 in 相同的事情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

于 2016-03-15T15:44:51.663 回答
26

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

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
于 2010-04-15T01:36:43.090 回答
13

另一种方法是使用tidy evaluation方法。将数据框的列作为字符串或裸列名称传递是非常简单的。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 包（v0.2.1.9000）于 2019 年 3 月 1 日创建

于 2019-03-01T15:51:04.280 回答
9

现在dplyr还可以通过简单地在函数体中的所需列名周围使用双花括号来访问数据帧的特定列{{...}}，例如col_name：

library(tidyverse)

fun <- function(df, col_name){
   df %>% 
     filter({{col_name}} == "test_string")
}
于 2020-11-18T14:26:10.650 回答
1

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

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）于 2019 年 1 月 11 日创建

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

于 2019-01-10T17:17:31.650 回答
0

如果您尝试在 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 语句是一种快速捕获方法。框架。也可以在这里使用 tryCatch 错误处理。

于 2020-10-04T03:39:33.163 回答