Передайте имя столбца data.frame функции - PullRequest
99 голосов
/ 15 апреля 2010

Я пытаюсь написать функцию, которая принимает 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() и match.call(), с которыми у меня нет большого опыта.

Подвопрос : do.call() предпочтительнее, чем eval()?

Ответы [ 5 ]

86 голосов
/ 15 апреля 2010

Вы можете просто использовать имя столбца напрямую:

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

Нет необходимости использовать замену, 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")
61 голосов
/ 15 марта 2016

Этот ответ будет охватывать многие из тех же элементов, что и существующие ответы, но эта проблема (передача имен столбцов функциям) возникает достаточно часто, поэтому я хотел, чтобы был ответ, который охватывал бы вещи немного более всесторонне.

Предположим, у нас очень простой фрейм данных:

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

Это часто считается «лучшей практикой», так как это метод, который сложнее всего испортить. Передача имен столбцов в виде строк - это однозначно, насколько это возможно.

Следующие два параметра более продвинуты. Многие популярные пакеты используют методы такого рода, но их использование хорошо требует большей осторожности и навыков, поскольку они могут внести незначительные сложности и непредвиденные точки отказа. Этот раздел книги Advanced R от Hadley является отличным справочником по некоторым из этих проблем.

Если вы действительно хотите избавить пользователя от ввода всех этих кавычек, один из вариантов может заключаться в том, чтобы преобразовать имена столбцов без кавычек в строки, используя 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 и т. Д., Если вы действительно знаете, что делаете.

20 голосов
/ 15 апреля 2010

Лично я считаю, что передавать столбец как строку довольно некрасиво Мне нравится делать что-то вроде:

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
6 голосов
/ 01 марта 2019

Другой способ - использовать 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
#>

Создано в 2019-03-01 пакетом Представление (v0.2.1.9000)

0 голосов
/ 10 января 2019

В качестве дополнительной мысли, если необходимо передать имя столбца без кавычек в пользовательскую функцию, возможно, 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

Создано в 2019-01-11 пакетом Представление (v0.2.1)

Не думаю, что я бы использовал этот подход, поскольку существует дополнительная типизация и сложность, чем просто передача имени столбца в кавычках, как указано в приведенных выше ответах, но, конечно же, это подход.

...