data.table-package 5
x$a and sum(x$a) as a vector respectively. x[, .(a, b)] and x[, .(sa=sum(a), sb=sum(b))]
returns a two column data.table each, the first simply selecting columns a, b
and the second computing their sums.
The expression ‘.()‘ is a shorthand alias to list(); they both mean the same.
As long as j returns a list, each element of the list becomes a column in the
resulting data.table. This is the default enhanced mode.
When with=FALSE, j can only be a vector of column names or positions to
select (as in data.frame).
Advanced: j also allows the use of special read-only symbols: .SD, .N, .I,
.GRP, .BY.
Advanced: When i is a data.table, the columns of i can be referred to in j by
using the prefix i., e.g., X[Y, .(val, i.val)]. Here val refers to X’s column
and i.val Y’s.
Advanced: Columns of x can now be referred to using the prefix x. and is par-
ticularly useful during joining to refer to x’s join columns as they are otherwise
masked by i’s. For example, X[Y, .(x.a-i.a, b), on="a"].
See Introduction to data.table vignette and examples.
by Column names are seen as if they are variables (as in j when with=TRUE). The
data.table is then grouped by the by and j is evaluated within each group. The
order of the rows within each group is preserved, as is the order of the groups.
by accepts:
• A single unquoted column name: e.g., DT[, .(sa=sum(a)), by=x]
• a list() of expressions of column names: e.g., DT[, .(sa=sum(a)), by=.(x=x>0, y)]
• a single character string containing comma separated column names (where
spaces are significant since column names may contain spaces even at the
start or end): e.g., DT[, sum(a), by="x,y,z"]
• a character vector of column names: e.g., DT[, sum(a), by=c("x", "y")]
• or of the form startcol:endcol: e.g., DT[, sum(a), by=x:z]
Advanced: When i is a list (or data.frame or data.table), DT[i, j, by=.EACHI]
evaluates j for the groups in ‘DT‘ that each row in i joins to. That is, you can
join (in i) and aggregate (in j) simultaneously. We call this grouping by each i.
See this StackOverflow answer for a more detailed explanation until we roll out
vignettes.
Advanced: In the X[Y, j] form of grouping, the j expression sees variables in
X first, then Y. We call this join inherited scope. If the variable is not in X or Y
then the calling frame is searched, its calling frame, and so on in the usual way
up to and including the global environment.
keyby Same as by, but with an additional setkey() run on the by columns of the result,
for convenience. It is common practice to use ‘keyby=‘ routinely when you wish
the result to be sorted.
with By default with=TRUE and j is evaluated within the frame of x; column names
can be used as variables.
When with=FALSE j is a character vector of column names, a numeric vector
of column positions to select or of the form startcol:endcol, and the value
returned is always a data.table. with=FALSE is often useful in data.table to
评论0