Wie verweisen Sie auf Variablen in a, data.tablewenn die Variablennamen in einem Zeichenvektor gespeichert sind? Dies funktioniert beispielsweise für data.frame:

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

Wie kann ich denselben Vorgang für eine Datentabelle mit oder ohne :=Notation ausführen ? Das Offensichtliche dt[ , list(colname)]funktioniert nicht (und ich habe es auch nicht erwartet).

Zwei Möglichkeiten zur programmgesteuerten Auswahl von Variablen:

1. with = FALSE::

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

2. ..Präfix 'dot dot' ( ):

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

Weitere Informationen zur.. Notation 'dot dot' ( ) finden Sie unter Neue Funktionen in 1.10.2 (derzeit nicht im Hilfetext beschrieben).

Um Variablen zuzuweisen , setzen Sie die LHS von :=in Klammern:

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

Letzteres wird als Spalten- Plonk bezeichnet , da Sie den gesamten Spaltenvektor durch Referenz ersetzen. Wenn eine Teilmenge ivorhanden wäre, würde sie durch Referenz untergeordnet. Die Parens (colname)sind eine Abkürzung, die in Version v1.9.4 auf CRAN Oct 2014 eingeführt wurde. Hier ist die Nachricht :

Die Verwendung with = FALSEmit :=ist jetzt in allen Fällen veraltet, da das Umschließen der LHS :=mit Klammern seit einiger Zeit bevorzugt wird.

colVar = "col1"
DT[, colVar := 1, with = FALSE]                 # deprecated, still works silently
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

Siehe auch Abschnitt Details in ?`:=`:

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

Und um weitere Fragen im Kommentar zu beantworten, gibt es eine Möglichkeit (wie üblich gibt es viele Möglichkeiten):

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

oder es ist möglicherweise einfacher, nur evaleine zu lesen, zu schreiben und zu debuggen paste, ähnlich wie beim Erstellen einer dynamischen SQL-Anweisung, die an einen Server gesendet werden soll:

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

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

Wenn Sie das häufig tun, können Sie eine Hilfsfunktion definieren EVAL:

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

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

Nun , da data.table1.8.2 automatisch optimiert jfür Effizienz, kann es vorteilhaft sein , die verwenden evalMethode. Das get()In jverhindert beispielsweise einige Optimierungen.

Oder gibt es set(). Eine funktionale Form mit geringem Overhead, :=die hier in Ordnung wäre. Siehe ?set.

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

* Dies ist eigentlich keine Antwort, aber ich habe nicht genug Straßenguthaben, um Kommentare zu posten: /

Für jeden, der tatsächlich eine neue Spalte in einer Datentabelle mit einem in einer Variablen gespeicherten Namen erstellen möchte, muss Folgendes funktionieren. Ich habe keine Ahnung, wie es funktioniert. Verbesserungsvorschläge? Ist es sicher anzunehmen, dass eine namenlose neue Spalte immer den Namen V1 erhält?

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

Beachten Sie, dass ich in der Summe () ganz gut darauf verweisen kann, es aber nicht dazu bringen kann, es im selben Schritt zuzuweisen. Übrigens, der Grund, warum ich dies tun muss, ist, dass colname auf Benutzereingaben in einer Shiny-App basiert.

Für mehrere Spalten und eine Funktion, die auf Spaltenwerte angewendet wird.

Wenn Sie die Werte einer Funktion aktualisieren, muss die RHS ein Listenobjekt sein. Wenn Sie also eine Schleife .SDmit verwenden lapply, reicht dies aus.

Im folgenden Beispiel werden ganzzahlige Spalten in numerische Spalten konvertiert

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" 

Sie könnten dies versuchen

colname <- as.name ("COL_NAME")

DT2 <- DT [, Liste (COL_SUM = Summe (eval (colname, .SD))), by = c (Gruppe)]

Abrufen mehrerer Spalten aus data.table über Variable oder Funktion:

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

was alle ergeben

   that whatever
1:    1        1
2:    2        2

Ich finde den .SDcolsWeg am elegantesten.