Jak odnosisz się do zmiennych w a, data.tablejeśli nazwy zmiennych są przechowywane w wektorze znakowym? Na przykład działa to w przypadku data.frame:

df <- data.frame(col1 = 1:3)
colname <- "col1"
df[colname] <- 4:6
df
#   col1
# 1    4
# 2    5
# 3    6

Jak mogę wykonać tę samą operację dla tabeli data.table, z :=notacją lub bez ? Oczywista rzecz dt[ , list(colname)]nie działa (i nie spodziewałem się tego).

Dwa sposoby programowego wybierania zmiennych:

1. with = FALSE:

    DT = data.table(col1 = 1:3)
    colname = "col1"
    DT[, colname, with = FALSE] 
    #    col1
    # 1:    1
    # 2:    2
    # 3:    3
   

2. ..Przedrostek „kropka kropka” ( ):

    DT[, ..colname]    
    #    col1
    # 1:    1
    # 2:    2
    # 3:    3
   

Więcej informacji na temat notacji „kropka kropka” ( ..) można znaleźć w sekcji Nowe funkcje w wersji 1.10.2 (obecnie nie jest ona opisana w tekście pomocy).

Aby przypisać do zmiennych, zawiń LHS lub :=w nawiasy:

DT[, (colname) := 4:6]    
#    col1
# 1:    4
# 2:    5
# 3:    6

Ten ostatni jest znany jako plonk kolumny , ponieważ zastępujesz cały wektor kolumny przez odniesienie. Jeśli podzbiór ibył obecny, będzie to przypisywanie podrzędne przez odniesienie. Parens (colname)to skrót wprowadzony w wersji v1.9.4 w CRAN w październiku 2014 r. Oto aktualności :

Używanie with = FALSEwith :=jest teraz przestarzałe we wszystkich przypadkach, biorąc pod uwagę, że zawijanie LHS :=z nawiasami jest preferowane od jakiegoś czasu.

colVar = "col1"

DT[, (colVar) := 1]                             # please change to this
DT[, c("col1", "col2") := 1]                    # no change
DT[, 2:4 := 1]                                  # no change
DT[, c("col1","col2") := list(sum(a), mean(b))]  # no change
DT[, `:=`(...), by = ...]                       # no change

Zobacz także sekcję Szczegóły w ?`:=`:

DT[i, (colnamevector) := value]
# [...] The parens are enough to stop the LHS being a symbol

Aby odpowiedzieć na dalsze pytanie w komentarzu, oto jeden sposób (jak zwykle jest wiele sposobów):

DT[, colname := cumsum(get(colname)), with = FALSE]
#    col1
# 1:    4
# 2:    9
# 3:   15 

lub, może być łatwiejsze czytanie, pisanie i debugowanie tylko do evala paste, podobnie do konstruowania dynamicznej instrukcji SQL do wysłania na serwer:

expr = paste0("DT[,",colname,":=cumsum(",colname,")]")
expr
# [1] "DT[,col1:=cumsum(col1)]"

eval(parse(text=expr))
#    col1
# 1:    4
# 2:   13
# 3:   28

Jeśli często to robisz, możesz zdefiniować funkcję pomocniczą EVAL:

EVAL = function(...)eval(parse(text=paste0(...)),envir=parent.frame(2))

EVAL("DT[,",colname,":=cumsum(",colname,")]")
#    col1
# 1:    4
# 2:   17
# 3:   45

Teraz, gdy data.table1.8.2 automatycznie optymalizuje się jpod kątem wydajności, preferowane może być użycie tej evalmetody. get()W jzabezpiecza pewne optymalizacje, na przykład.

Albo jest set(). Niska, funkcjonalna forma :=, która byłaby tutaj w porządku. Zobacz ?set.

set(DT, j = colname, value = cumsum(DT[[colname]]))
DT
#    col1
# 1:    4
# 2:   21
# 3:   66

* To nie jest prawdziwa odpowiedź, ale nie mam wystarczających danych na temat ulicy, aby dodawać komentarze: /

W każdym razie, dla każdego, kto chciałby faktycznie utworzyć nową kolumnę w tabeli danych z nazwą przechowywaną w zmiennej, mam do pracy następujące rzeczy. Nie mam pojęcia, jak to działa. Jakieś sugestie dotyczące ulepszeń? Czy można bezpiecznie założyć, że bezimienna nowa kolumna zawsze otrzyma nazwę V1?

colname <- as.name("users")
# Google Analytics query is run with chosen metric and resulting data is assigned to DT
DT2 <- DT[, sum(eval(colname, .SD)), by = country]
setnames(DT2, "V1", as.character(colname))

Zauważ, że mogę odwołać się do tego w sumie (), ale nie mogę go przypisać w tym samym kroku. BTW, powodem, dla którego muszę to zrobić, jest to, że nazwa kolumny będzie oparta na danych wprowadzonych przez użytkownika w aplikacji Shiny.

Dla wielu kolumn i funkcji zastosowanej do wartości kolumn.

Podczas aktualizowania wartości z funkcji, RHS musi być obiektem listy, więc użycie pętli na .SDwith lapplyzałatwi sprawę.

Poniższy przykład konwertuje kolumny liczb całkowitych na kolumny liczbowe

a1 <- data.table(a=1:5, b=6:10, c1=letters[1:5])
sapply(a1, class)  # show classes of columns
#         a           b          c1 
# "integer"   "integer" "character" 

# column name character vector
nm <- c("a", "b")

# Convert columns a and b to numeric type
a1[, j = (nm) := lapply(.SD, as.numeric ), .SDcols = nm ]

sapply(a1, class)
#         a           b          c1 
# "numeric"   "numeric" "character" 

Pobierz wiele kolumn z data.table za pomocą zmiennej lub funkcji:

library(data.table)

x <- data.table(this=1:2,that=1:2,whatever=1:2)

# === explicit call
x[, .(that, whatever)]
x[, c('that', 'whatever')]

# === indirect via  variable
# ... direct assignment
mycols <- c('that','whatever')
# ... same as result of a function call
mycols <- grep('a', colnames(x), value=TRUE)

x[, ..mycols]
x[, .SD, .SDcols=mycols]

# === direct 1-liner usage
x[, .SD, .SDcols=c('that','whatever')]
x[, .SD, .SDcols=grep('a', colnames(x), value=TRUE)]

które wszystkie dają

   that whatever
1:    1        1
2:    2        2

Uważam, że .SDcolsdroga jest najbardziej elegancka.

Możesz tego spróbować

colname <- as.name („COL_NAME”)

DT2 <- DT [, list (COL_SUM = sum (eval (nazwa kolumny, .SD))), by = c (grupa)]