Passe um nome de coluna data.frame para uma função

Estou tentando escrever uma função para aceitar um data.frame ( x) e um columndele. A função executa alguns cálculos em xe posteriormente retorna outro data.frame. Estou preso no método de práticas recomendadas para passar o nome da coluna para a função.

Os dois exemplos mínimos fun1e fun2abaixo produzem o resultado desejado, podendo realizar operações no x$column, utilizando max()como exemplo. No entanto, ambos contam com o aparentemente (pelo menos para mim) deselegante

1. ligue para substitute()e possivelmenteeval()
2. a necessidade de passar o nome da coluna como um vetor de caracteres.

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

Gostaria de poder chamar a função como fun(df, B), por exemplo. Outras opções que considerei, mas não tentei:

• Passe columncomo um inteiro do número da coluna. Acho que isso evitaria substitute(). Idealmente, a função poderia aceitar qualquer um.
• with(x, get(column)), mas, mesmo que funcione, acho que ainda exigiria substitute
• Faça uso de formula()e match.call(), nenhum dos quais tenho muita experiência.

Subquestão : É do.call()preferível eval()?

Você pode apenas usar o nome da coluna diretamente:

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

Não há necessidade de usar substituto, eval, etc.

Você pode até passar a função desejada como parâmetro:

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

Como alternativa, usar [[também funciona para selecionar uma única coluna por vez:

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

Essa resposta abrangerá muitos dos mesmos elementos das respostas existentes, mas esse problema (passar nomes de colunas para funções) surge com frequência o suficiente para que houvesse uma resposta que abrangesse as coisas de forma um pouco mais abrangente.

Suponha que temos um quadro de dados muito simples:

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

e gostaríamos de escrever uma função que crie uma nova coluna zque é a soma das colunas xe y.

Um obstáculo muito comum aqui é que uma tentativa natural (mas incorreta) geralmente se parece com isto:

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

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

O problema aqui é que df$col1não avalia a expressão col1. Ele simplesmente procura uma coluna dfliteralmente chamada col1. Este comportamento é descrito em?Extract seção "Objetos recursivos (semelhantes a listas)".

A solução mais simples e mais frequentemente recomendada é simplesmente alternar de $para [[e passar os argumentos da função como strings:

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

Isso geralmente é considerado a "melhor prática", pois é o método mais difícil de errar. Passar os nomes das colunas como strings é o mais inequívoco que você pode imaginar.

As duas opções a seguir são mais avançadas. Muitos pacotes populares fazem uso desses tipos de técnicas, mas usá-los bem requer mais cuidado e habilidade, pois podem apresentar complexidades sutis e pontos de falha imprevistos. Esta seção do livro Advanced R de Hadley é uma excelente referência para alguns desses problemas.

Se você realmente deseja evitar que o usuário digite todas as aspas, uma opção pode ser converter os nomes das colunas vazias e não citadas em strings usando 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

Isso é, francamente, um pouco bobo provavelmente, já que estamos realmente fazendo a mesma coisa que em new_column1, apenas com um monte de trabalho extra para converter nomes simples em strings.

Finalmente, se quisermos ser realmente sofisticados, podemos decidir que, em vez de passar os nomes de duas colunas a serem adicionadas, gostaríamos de ser mais flexíveis e permitir outras combinações de duas variáveis. Nesse caso, provavelmente recorreríamos ao uso eval()de uma expressão envolvendo as duas colunas:

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

Só por diversão, ainda estou usando deparse(substitute())para o nome da nova coluna. Aqui, todos os itens a seguir funcionarão:

> 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

Portanto, a resposta curta é basicamente: passe os nomes das colunas data.frame como strings e use [[para selecionar colunas únicas. Apenas começar a se aprofundar eval, substituteetc. se você realmente sabe o que está fazendo.

Pessoalmente, acho que passar a coluna como uma string é muito feio. Eu gosto de fazer algo como:

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

que renderá:

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

Observe como a especificação de um data.frame é opcional. você pode até trabalhar com funções de suas colunas:

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

Outra maneira é usar a tidy evaluationabordagem. É muito simples passar colunas de um quadro de dados como strings ou nomes de coluna vazios. Veja mais sobre tidyeval aqui .

library(rlang)
library(tidyverse)

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

Use os nomes das colunas como strings

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

Use nomes de coluna simples

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
#>

^{Criado em 01/03/2019 pelo pacote reprex (v0.2.1.9000)}

Como um pensamento extra, se for necessário passar o nome da coluna sem aspas para a função personalizada, talvez match.call()possa ser útil também neste caso, como uma alternativa para 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

Se houver um erro de digitação no nome da coluna, seria mais seguro parar com um erro:

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

^{Criado em 11/01/2019 pelo pacote reprex (v0.2.1)}

Não acho que usaria essa abordagem, pois há digitação e complexidade extras do que apenas passar o nome da coluna citada conforme apontado nas respostas acima, mas bem, é uma abordagem.