Pase el nombre de la variable como argumento dentro de data.table

Question

Estoy tratando de crear una función que modifique una tabla data.table y quería usar alguna evaluación no estándar, pero me di cuenta de que realmente no sé cómo trabajar con ella dentro de data.tables. Mi función es básicamente algo como esto:

do_stuff <- function(dt, col) {
  copy(dt)[, new_col := some_fun(col)][]
}

y quiero llamarlo así:

do_stuff(data, column)

Donde "columna" es el nombre de la columna que existe dentro de "datos". Si ejecuto esa función me sale un error:

#> Error in some_fun(col) : object ''column'' not found 

Lo que me dice que data.table aparentemente está pasando el nombre correcto a la función ("columna") pero por alguna razón no lo está encontrando. Aquí hay un ejemplo mínimo reproducible

library(data.table)

data <- data.table(x = 1:10, y = rnorm(10))

plus <- function(x, y) {
   x + y
}

add_one <- function(data, col) {
   copy(data)[, z := plus(col, 1)][]
}

add_one(data, y)
#> Error in plus(col, 1): object ''y'' not found

El uso de deparse(substitute(col)) no parece funcionar, desafortunadamente :(

add_one <- function(data, col) {
   copy(data)[, z := plus(deparse(substitute(col)), 1)][]
}

add_one(data, y)
#> Error in x + y: non-numeric argument to binary operator

Answer 1

Aunque es potencialmente más propenso a errores, puede confiar en ... argumentos.

data <- data.table(x = 1:10, y = rnorm(10))

plus <- function(x, y) {
  x + y
}

add_one <- function(data, ...) {
  copy(data)[, z:= plus(data[, ...], 1)][]
}

add_one(data, y)

#or
library(dplyr)
data.table(x = 1:10, y = rnorm(10))%>%
  add_one(y)

     x           y          z
 1:  1 -1.29851891 -0.2985189
 2:  2 -1.36494928 -0.3649493
 3:  3  0.38282492  1.3828249
 4:  4  1.24578886  2.2457889
 5:  5  1.12897695  2.1289770
 6:  6 -0.80122005  0.1987800
 7:  7  1.89093661  2.8909366
 8:  8 -0.34525212  0.6547479
 9:  9 -0.07070159  0.9292984
10: 10 -1.94145962 -0.9414596

Desafortunadamente, expandir esto a múltiples variables conduciría al fracaso. Aún así, puede usar el ... para su ventaja.

add_one2 <- function(data, ...){
  copy(data)[...][]
}
add_one2(data, , z:=plus(y, 1))

     x          y          z
 1:  1 -0.1565010  0.8434990
 2:  2  0.6516824  1.6516824
 3:  3  0.5355833  1.5355833
 4:  4  0.1941661  1.1941661
 5:  5  0.2994167  1.2994167
 6:  6 -2.5681215 -1.5681215
 7:  7 -1.4587147 -0.4587147
 8:  8  0.9375132  1.9375132
 9:  9  1.3984343  2.3984343
10: 10 -0.6498709  0.3501291

Answer 2

En general, presupuesto y evaluación funcionarán:

library(data.table)
plus <- function(x, y) {
   x + y
}

add_one <- function(data, col) {
   expr0 = quote(copy(data)[, z := plus(col, 1)][])

   expr  = do.call(substitute, list(expr0, list(col = substitute(col))))
   cat("Evaluated expression:/n"); print(expr); cat("/n")

   eval(expr)
}

set.seed(1)
library(magrittr)
data.table(x = 1:10, y = rnorm(10)) %>% 
   add_one(y)

lo que da

Evaluated expression:
copy(data)[, `:=`(z, plus(y, 1))][]

     x          y         z
 1:  1 -0.6264538 0.3735462
 2:  2  0.1836433 1.1836433
 3:  3 -0.8356286 0.1643714
 4:  4  1.5952808 2.5952808
 5:  5  0.3295078 1.3295078
 6:  6 -0.8204684 0.1795316
 7:  7  0.4874291 1.4874291
 8:  8  0.7383247 1.7383247
 9:  9  0.5757814 1.5757814
10: 10 -0.3053884 0.6946116

Answer 3

Otra opción, citando el nombre de la columna y usando get :

add_one <- function(data, col) {
  copy(data)[, z := plus(get(col), 1)][]
}

add_one(data, "y")

Answer 4

Un extracto de mis Rnotebooks ... para la serie / análisis de datos de series de tiempo. Utilizo este patrón para mi propio paquete para envolver paquetes data.table y de series temporales (es decir, xts).

# Non-standard evaluation & wrapper for data.table

data <- data.table(a = 1:2, b = 3:4)    

## Non-in-place update - - - - - - - - -

do_something <- function(data, col) {
  col <- eval( substitute(col), data )
  data[ , col + 123]
}
data %>% do_something(a)

## In-place update without copies (fast, memory efficient) - - - - - - - - -

# Minimalistic example        
do_something <- function(data, col) {
  col <- eval( substitute(col), data )
  data[ , new_col := col + 123]
}
data %>% do_something(a)   # print `data` to see results

# More example
# optional multi-assignment %<-% operator from {zeallot} for cleaner syntax    
my_func <- function(x, y) x + y

do_something <- function(data, col_1, col_2, col_name) {
  c(col_1, col_2) %<-% map(
    c( substitute(col_1), substitute(col_2) ), ~ eval( ., data )
  )
  data[ , (col_name) := my_func(col_1, col_2)]
}
data %>% do_something(a, b, ''new_col_name'')

# Advanced example
# ...

Answer 5

Una opción sería extraer el argumento sin comillas como una cadena con deparse(substitute y especificar eso en los .SDcols

add_one <- function(data, col) {
   copy(data)[, z := plus(.SD[[1]], 1), .SDcols = deparse(substitute(col))][]
 }

add_one(data, y)
#     x           y          z
# 1:  1  0.50269855  1.5026986
# 2:  2 -0.33022414  0.6697759
# 3:  3  0.57517246  1.5751725
# 4:  4  1.09928586  2.0992859
# 5:  5  0.84683311  1.8468331
# 6:  6 -1.42023443 -0.4202344
# 7:  7  0.04539331  1.0453933
# 8:  8  0.11870596  1.1187060
# 9:  9 -1.11735007 -0.1173501
#10: 10 -1.94834136 -0.9483414

o usando get

add_one <- function(data, col) {
   copy(data)[, z := plus(get(deparse(substitute(col)))][]
 }

O usando tidyverse

library(tidyverse)
add_one <- function(data, col, col2) {
   data %>%
         dplyr::mutate(z =plus({{col}}, {{col2}}))
  }

add_one(data, x, y)
#    x           y         z
#1   1 -0.53389875 0.4661013
#2   2  1.28743777 3.2874378
#3   3 -1.26674091 1.7332591
#4   4  0.95017120 4.9501712
#5   5  0.06741833 5.0674183
#6   6 -0.70212949 5.2978705
#7   7 -0.38003803 6.6199620
#8   8 -0.50941072 7.4905893
#9   9  0.54055720 9.5405572
#10 10 -0.87486953 9.1251305