javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

r-如何从data.table中排除一列或如何将data.table转换为MT

使用df = as.data.frame(dt)时是否可以像zoo一样返回除一列以外的所有列?

如果答案是否定的,那么是否有人能以优雅的方式将多个时间序列df = as.data.frame(dt)转换为zoo或其他时间序列对象?

考虑以下示例:

library(data.table)
library(zoo)

## DEFINE DATA
set.seed(1)
dt = data.table(
    mydates = as.Date("2012-01-01") + 1:9, 
    value1 = sort(rpois(9, 6)),
    value2 = sort(rpois(9, 6)),
    value3 = sort(rpois(9, 6)),
    value4 = sort(rpois(9, 6)),
    value5 = sort(rpois(9, 6)))

## CONVERT TO DATA FRAME
df = as.data.frame(dt)

## CONVERT TO ZOO
zooObj = zoo(df[,-1], df$mydates)

## EXAMPLE OF DESIRED RESULTS
plot(zooObj, col=1:ncol(zooObj))

没有df = as.data.frame(dt)怎么办?

trans by 2020-02-17T16:23:36Z

r-如何执行data.table合并操作

注意:这个问题和以下答案是指data.table版本<1.5.3; 1.5.3版于2011年2月发布,以解决此问题。 查看更多近期处理(03-2012):将外键上的SQL联接转换为R data.table语法


我一直在仔细阅读data.table软件包的文档(替代data.frame,对于某些操作而言效率更高),包括Josh Reich在NYC R Meetup(pdf)上有关SQL和data.table的演示,但是 无法弄清楚这种完全琐碎的操作。

> x <- DT(a=1:3, b=2:4, key='a')
> x
     a b
[1,] 1 2
[2,] 2 3
[3,] 3 4
> y <- DT(a=1:3, c=c('a','b','c'), key='a')
> y
     a c
[1,] 1 a
[2,] 2 b
[3,] 3 c
> x[y]
     a b
[1,] 1 2
[2,] 2 3
[3,] 3 4
> merge(x,y)
  a b c
1 1 2 a
2 2 3 b
3 3 4 c

文档说:“ [[第一个参数]本身是data.table时,将类似于base :: merge调用联接,但对已排序的键使用二进制搜索。” 显然并非如此。 我可以使用data.tables将y中的其他列获取到x [y]的结果中吗? 似乎只是将x的行与键与y的键匹配,而完全忽略了y的其余部分...

trans by 2020-02-14T08:35:59Z

r-通过data.tab中的by连接继承的作用域

我在data.table 1.9.3上,也许我错了,但我不记得以下是之前预期的。

我建立2个data.tables,dta和dtb

> dta
   idx vala fdx
1:   1    2   a
2:   2    4   a
3:   3    6   b

> dtb
   idx valb
1:   1    3
2:   4    6

> dput(x = dta)
structure(list(idx = c(1, 2, 3), vala = c(2, 4, 6), fdx = c("a",
"a", "b")), .Names = c("idx", "vala", "fdx"), row.names = c(NA,
-3L), class = c("data.table", "data.frame"), .internal.selfref =
<pointer: 0x0000000000110788>, sorted = "idx")

> dput(x = dtb)
structure(list(idx = c(1, 4), valb = c(3, 6)), .Names = c("idx",
"valb"), row.names = c(NA, -2L), class = c("data.table", "data.frame"
), .internal.selfref = <pointer: 0x0000000000110788>, sorted = "idx")

在这两种情况下,密钥都是idx。

当然,以下作品

> dta[dtb, sum(valb)]
[1] 9

但是,这不是

> dta[dtb, sum(valb), by = fdx]
Error in `[.data.table`(dta, dtb, sum(valb), by = fdx) :
  object 'valb' not found

但这确实

> dta[dtb][, sum(valb), by = fdx]
   fdx V1
1:   a  3
2:  NA  6

如果我们看到中间步骤

> dta[dtb]
   idx vala fdx valb
1:   1    2   a    3
2:   4   NA  NA    6

我本来期望

dta[dtb, sum(valb), by = fdx] == dta[dtb][, sum(valb), by = fdx]

我哪里出问题了?

trans by 2020-02-10T11:24:02Z

r-适用于大型data.tab的write.csv

我有一个不是很大的(2 GB)data.table,但是由于某种原因data.frame花费了很长的时间才能将其写出(我从未真正完成等待),并且似乎要使用大量的RAM来完成它。

我尝试将data.table转换为data.frame,尽管自data.table扩展了data.frame以来,这实际上不应该做任何事情。

更重要的是,如果您使用Ctrl-C停止它,R似乎不会退还内存。

trans by 2020-02-08T13:16:26Z

r-按升序/降序对data.table快速排序

我有一个约300万行40列的data.table。 我想按以下sql模拟代码之类的组内的降序对表进行排序:

sort by ascending Year, ascending MemberID, descending Month 

在data.table中有等效的方法吗? 到目前为止,我必须将其分为两个步骤:

setkey(X, Year, MemberID)

这非常快,只需几秒钟。

X <- X[,.SD[order(-Month)],by=list(Year, MemberID)]

此步骤花费了更长的时间(5分钟)。

更新:有人发表评论X <- X[sort(Year, MemberID, -Month)],然后将其删除。 这种方法似乎要快得多:

user  system elapsed 
5.560  11.242  66.236 

我的方法:setkey()然后order(-Month)

   user  system elapsed 
816.144   9.648 848.798 

我现在的问题是:如果我想按排序后的年,会员编号和月(年,会员编号,月)进行汇总,data.table是否可以识别排序顺序?

更新2:回应Matthew Dowle:

用Year,MemberID和Month设置setkey之后,我仍然每个组有多个记录。 我想对每个小组进行总结。 我的意思是:如果我使用X [order(Year,MemberID,Month)],求和是否使用data.table的二进制搜索功能:

monthly.X <- X[, lapply(.SD[], sum), by = list(Year, MemberID, Month)]

更新3:Matthew D提出了几种方法。 第一种方法的运行时间比order()方法快:

   user  system elapsed 
  7.910   7.750  53.916 

马修:大部分时间使我感到惊讶的是,转换月份的符号。 没有它,setkey将会迅速发展。

trans by 2020-02-06T05:38:51Z

r-使用data.tab按组分组

假设我有一个包含一些棒球选手的数据表:

library(plyr)
library(data.table)

bdt <- as.data.table(baseball)

对于每个玩家(按ID给出),我想找到与他们玩游戏最多的年份相对应的行。 这在plyr中很简单:

ddply(baseball, "id", subset, g == max(g))

data.table的等效代码是什么?

我试过了:

setkey(bdt, "id") 
bdt[g == max(g)]  # only one row
bdt[g == max(g), by = id]  # Error: 'by' or 'keyby' is supplied but not j
bdt[, .SD[g == max(g)]] # only one row

这有效:

bdt[, .SD[g == max(g)], by = id] 

但这仅比plyr快30%,这表明它可能不是惯用语言。

trans by 2020-01-29T04:04:00Z

r-使用data.tab汇总多列

我正在尝试使用data.table来加速处理由几个较小的合并data.frames组成的大data.frame(300k x 60)。 我是data.table的新手。 到目前为止的代码如下

library(data.table)
a = data.table(index=1:5,a=rnorm(5,10),b=rnorm(5,10),z=rnorm(5,10))
b = data.table(index=6:10,a=rnorm(5,10),b=rnorm(5,10),c=rnorm(5,10),d=rnorm(5,10))
dt = merge(a,b,by=intersect(names(a),names(b)),all=T)
dt$category = sample(letters[1:3],10,replace=T)

我想知道是否有比以下方式更有效的方式来汇总数据。

summ = dt[i=T,j=list(a=sum(a,na.rm=T),b=sum(b,na.rm=T),c=sum(c,na.rm=T),
                     d=sum(d,na.rm=T),z=sum(z,na.rm=T)),by=category]

我真的不想手动输入所有50列计算,并且eval(paste(...))似乎有点笨拙。

我看了下面的示例,但是对于我的需求来说似乎有点复杂。 谢谢

如何汇总多个列中的data.table

trans by 2020-01-17T15:05:57Z

r-计算记录数并在data.tab中的每个组内生成行号

我有以下数据表

set.seed(1)
DT <- data.table(VAL = sample(c(1, 2, 3), 10, replace = TRUE))
    VAL
 1:   1
 2:   2
 3:   2
 4:   3
 5:   1
 6:   3
 7:   3
 8:   2
 9:   2
10:   1

data.table中的每个数字内,我要:

  1. 计算记录/行数
  2. 创建第一,第二,第三次出现等的行索引(计数器)。

最后我想要结果

    VAL COUNT IDX
 1:   1     3   1
 2:   2     4   1
 3:   2     4   2
 4:   3     3   1
 5:   1     3   2
 6:   3     3   2
 7:   3     3   3
 8:   2     4   3
 9:   2     4   4
10:   1     3   3

其中“ COUNT”是每个“ VAL”的记录/行数,“ IDX”是每个“ VAL”内的行索引。

我尝试使用.I[]data.table.I[]

 dt[, list(COUNT = length(VAL == VAL[.I]), 
             IDX = which(which(VAL == VAL[.I]) == .I))]

但这不起作用,因为data.table指向带有索引的向量,所以我猜一个人必须使用.I[]。尽管在.I[]内部,我再次遇到问题,我没有行索引,并且我确实知道(通过阅读data.table419 FAQ和 遵循此处的帖子),如果可能的话,应避免循环遍历行。

那么,什么是data.table方式?

trans by 2019-11-13T13:59:31Z

r-如何在每个组中创建滞后变量?

我有一个data.table:

set.seed(1)
data <- data.table(time = c(1:3, 1:4),
                   groups = c(rep(c("b", "a"), c(3, 4))),
                   value = rnorm(7))

data
#    groups time      value
# 1:      b    1 -0.6264538
# 2:      b    2  0.1836433
# 3:      b    3 -0.8356286
# 4:      a    1  1.5952808
# 5:      a    2  0.3295078
# 6:      a    3 -0.8204684
# 7:      a    4  0.4874291

我想在“组”的每个级别中计算“值”列的滞后版本。

结果应该看起来像

#   groups time      value  lag.value
# 1      a    1  1.5952808         NA
# 2      a    2  0.3295078  1.5952808
# 3      a    3 -0.8204684  0.3295078
# 4      a    4  0.4874291 -0.8204684
# 5      b    1 -0.6264538         NA
# 6      b    2  0.1836433 -0.6264538
# 7      b    3 -0.8356286  0.1836433

我尝试直接使用lag

data$lag.value <- lag(data$value) 

...这显然行不通。

我也尝试过:

unlist(tapply(data$value, data$groups, lag))
 a1         a2         a3         a4         b1         b2         b3 
 NA -0.1162932  0.4420753  2.1505440         NA  0.5894583 -0.2890288 

这几乎是我想要的。 但是,生成的向量的顺序与data.table中的顺序不同,这是有问题的。

在R,plyr,dplyr和data.table中执行此操作的最有效方法是什么?

trans by 2019-11-05T14:51:16Z

r-按组提取与变量最小值对应的行

我希望(1)通过一个变量(min)对数据进行分组,(2)在每个组内找到另一个变量(Company)的最小值的行,以及(3)提取整行。

(1)和(2)是简单的一线客,我觉得(3)也是,但我不明白。

这是一个示例数据集:

> data
  State Company Employees
1    AK       A        82
2    AK       B       104
3    AK       C        37
4    AK       D        24
5    RI       E        19
6    RI       F       118
7    RI       G        88
8    RI       H        42

data <- structure(list(State = structure(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 
        2L), .Label = c("AK", "RI"), class = "factor"), Company = structure(1:8, .Label = c("A", 
        "B", "C", "D", "E", "F", "G", "H"), class = "factor"), Employees = c(82L, 
        104L, 37L, 24L, 19L, 118L, 88L, 42L)), .Names = c("State", "Company", 
        "Employees"), class = "data.frame", row.names = c(NA, -8L))

使用Company可轻松按组计算min

> aggregate(Employees ~ State, data, function(x) min(x))
  State Employees
1    AK        24
2    RI        19

...或min

> library(data.table)
> DT <- data.table(data)
> DT[ , list(Employees = min(Employees)), by = State]
   State Employees
1:    AK        24
2:    RI        19

但是如何提取与这些min值相对应的整行,即在结果中还包括Company

trans by 2019-11-05T01:24:34Z

R-.EACHI在data.table中?

我似乎在DT中找不到有关DT的确切功能的任何文档。我在文档中看到对此的简短提及:

已知组子集的聚合特别有效   当在i中传递这些组并设置DT时。当DT是   data.table,DT[i,j,by=my_grouping_variable]DT的组评估.EACHI,   i中的每一行都会加入。 我们称每个i为分组。

但是,在DT的上下文中,“组”是什么意思? 是由DT上设置的密钥确定的组吗? 该组是否是使用所有列作为键的每个不同的行? 我完全了解如何运行类似DT[i,j,by=my_grouping_variable]的程序,但是对于.EACHI的工作方式感到困惑。 有人可以解释一下吗?

trans by 2019-10-08T18:16:39Z

在一个函数调用中将多列添加到R data.table?

我有一个函数,该函数在列表中返回两个值。 这两个值都需要在两个新列中添加到data.table中。 函数评估成本很高,因此我想避免必须两次计算函数。 这是示例:

library(data.table)
example(data.table)
DT
   x y  v
1: a 1 42
2: a 3 42
3: a 6 42
4: b 1  4
5: b 3  5
6: b 6  6
7: c 1  7
8: c 3  8
9: c 6  9

这是我的功能的一个例子。 记住,我说过这是昂贵的计算,最重要的是,无法从其他给定值中推断出一个返回值(如下例所示):

myfun <- function (y, v) 
{
ret1 = y + v
ret2 = y - v
return(list(r1 = ret1, r2 = ret2))
}

这是在一条语句中添加两列的方法。 但是,需要两次调用myfun:

DT[,new1:=myfun(y,v)$r1][,new2:=myfun(y,v)$r2]

   x y  v new1 new2
1: a 1 42   43  -41
2: a 3 42   45  -39
3: a 6 42   48  -36
4: b 1  4    5   -3
5: b 3  5    8   -2
6: b 6  6   12    0
7: c 1  7    8   -6
8: c 3  8   11   -5
9: c 6  9   15   -3

有关如何执行此操作的任何建议? 每次调用myfun时,我都可以在单独的环境中保存r2,我只需要一种通过引用一次添加两列的方法。

trans by 2019-09-30T11:32:46Z

在R data.table计算中使用上一行的值

我想在data.table中创建一个新列,该列是根据一列的当前值和另一列的前值计算得出的。 是否可以访问以前的行?

例如。:

> DT <- data.table(A=1:5, B=1:5*10, C=1:5*100)
> DT
   A  B   C
1: 1 10 100
2: 2 20 200
3: 3 30 300
4: 4 40 400
5: 5 50 500
> DT[, D := C + BPreviousRow] # What is the correct code here?

正确答案应该是

> DT
   A  B   C   D
1: 1 10 100  NA
2: 2 20 200 210
3: 3 30 300 320
4: 4 40 400 430
5: 5 50 500 540
trans by 2019-09-25T12:36:51Z

r-两个(或多个)向量中所有元素的唯一组合

我试图在R中创建两个不同大小的矢量的所有元素的独特组合。

例如,第一个向量是

> a <- c("ABC", "DEF", "GHI")

第二个是当前存储为字符串的日期

> b <- c("2012-05-01", "2012-05-02", "2012-05-03", "2012-05-04", "2012-05-05")

我需要用两列创建一个数据框

> data
    a          b
1  ABC 2012-05-01
2  ABC 2012-05-02
3  ABC 2012-05-03
4  ABC 2012-05-04
5  ABC 2012-05-05
6  DEF 2012-05-01
7  DEF 2012-05-02
8  DEF 2012-05-03
9  DEF 2012-05-04
10 DEF 2012-05-05
11 GHI 2012-05-01
12 GHI 2012-05-02
13 GHI 2012-05-03
14 GHI 2012-05-04
15 GHI 2012-05-05

所以基本上,我正在寻找一个独特的组合,考虑一个向量的所有元素(a)与第二个向量(b)的所有元素并置。

理想的解决方案将推广到更多的输入向量。


也可以看看:
如何生成组合矩阵

trans by 2019-09-20T01:26:04Z

性能 - 在R中合并/加入data.frames的最快方法是什么?

例如(不确定是否最具代表性的例子):

N <- 1e6
d1 <- data.frame(x=sample(N,N), y1=rnorm(N))
d2 <- data.frame(x=sample(N,N), y2=rnorm(N))

这是我到目前为止所得到的:

d <- merge(d1,d2)
# 7.6 sec

library(plyr)
d <- join(d1,d2)
# 2.9 sec

library(data.table)
dt1 <- data.table(d1, key="x")
dt2 <- data.table(d2, key="x")
d <- data.frame( dt1[dt2,list(x,y1,y2=dt2$y2)] )
# 4.9 sec

library(sqldf)
sqldf()
sqldf("create index ix1 on d1(x)")
sqldf("create index ix2 on d2(x)")
d <- sqldf("select * from d1 inner join d2 on d1.x=d2.x")
sqldf()
# 17.4 sec
trans by 2019-08-13T01:38:06Z

r - 在data.table中设置密钥的目的是什么?

我正在使用data.table,并且有许多功能需要我设置密钥(例如setkey())。 因此,我希望了解密钥在我的数据表中正确设置密钥的作用。


我读过的一个来源是setkey()

setkey()memcpy进行排序并将其标记为已排序。 排序列是关键。 密钥可以是任何顺序的任何列。 列始终按升序排序。 该表通过引用更改。 除了临时工作内存大到一列之外,根本不会复制。

我在这里得到的一个关键是&#34;排序&#34; data.table,产生与memcpy非常相似的效果。但是,它并没有解释拥有密钥的目的。


data.table FAQ 3.2和3.3解释了:

3.2我在大桌子上没有钥匙,但分组仍然非常快。 这是为什么?

data.table使用基数排序。 这明显快于其他人   排序算法。 Radix仅用于整数,请参阅   memcpy.这也是原因之一   setkey()很快。 没有设置密钥时,或者我们按不同的顺序分组   从密钥的角度来看,我们称之为临时。

3.3为什么密钥中的列按比ad hoc更快的分组?

因为每个组在RAM中是连续的,从而最小化页面   提取和内存可以批量复制(memcpy in C)而不是   在C中循环

从这里开始,我想设置一个键以某种方式允许R使用&#34;基数排序&#34; 而不是其他算法,这就是它更快的原因。


10分钟快速入门指南还有一个按键指南。

  1. 按键

让我们从考虑data.frame,特别是rownames(或在   英文,行名)。 也就是说,属于单个的多个名称   行。 属于单行的多个名称? 那不是什么   我们习惯于data.frame。 我们知道每行最多只有一行   名称。 一个人至少有两个名字,第一个名字和第二个名字。   这对于组织电话目录很有用,例如,哪个   按姓氏排序,然后是rst姓名。 但是,每一行都有一个   data.frame只能有一个名称。

密钥由一个或多个组成   rownames的列,可以是整数,因子,字符或一些   其他课程,不仅仅是性格。 此外,行按排序   钥匙。 因此,data.table最多只能有一个键,因为它   不能以多种方式排序。

唯一性未强制执行,   即,允许重复的键值。 由于行按排序   密钥,密钥中的任何重复项将连续出现

电话簿有助于理解密钥是什么,但与具有因子列相比,似乎密钥没有区别。 此外,它没有解释为什么需要密钥(特别是使用某些功能)以及如何选择要设置为密钥的列。 此外,似乎在data.table中将time作为列,将任何其他列设置为键也可能会使时间列混乱,这使得它更加混乱,因为我不知道是否允许将任何其他列设置为 键。 有人可以开导我吗?

trans by 2019-07-27T15:12:30Z

r - 如何重新排序data.table列(无需复制)

我想重新排序data.table x中的列,给定列名称的字符向量,neworder

library(data.table)
x <- data.table(a = 1:3, b = 3:1, c = runif(3))
neworder <- c("c", "b", "a")

显然我可以这样做:

x[ , neworder, with = FALSE]
# or
x[ , ..neworder]
#            c b a
# 1: 0.8476623 3 1
# 2: 0.4787768 2 2
# 3: 0.3570803 1 3

但这需要再次复制整个数据集。 还有另一种方法吗?

trans by 2019-07-25T23:40:42Z

r - 使用:= data.table,按组分配多个列

使用col_names分配给多个列的最佳方法是什么? 例如:

f <- function(x) {c("hi", "hello")}
x <- data.table(id = 1:10)

我想做这样的事情(当然这种语法不正确):

x[ , (col1, col2) := f(), by = "id"]

为了扩展它,我可能有许多名称存储在变量中的列(例如col_names),我想这样做:

x[ , col_names := another_f(), by = "id", with = FALSE]

做这样的事的正确方法是什么?

trans by 2019-07-20T22:36:10Z

r - 转换data.tab中的列类

我在使用data.table时遇到问题:如何转换列类? 这是一个简单的例子:使用data.frame我没有转换它的问题,data.table我只是不知道如何:

df <- data.frame(ID=c(rep("A", 5), rep("B",5)), Quarter=c(1:5, 1:5), value=rnorm(10))
#One way: http://stackoverflow.com/questions/2851015/r-convert-data-frame-columns-from-factors-to-characters
df <- data.frame(lapply(df, as.character), stringsAsFactors=FALSE)
#Another way
df[, "value"] <- as.numeric(df[, "value"])

library(data.table)
dt <- data.table(ID=c(rep("A", 5), rep("B",5)), Quarter=c(1:5, 1:5), value=rnorm(10))
dt <- data.table(lapply(dt, as.character), stringsAsFactors=FALSE) 
#Error in rep("", ncol(xi)) : invalid 'times' argument
#Produces error, does data.table not have the option stringsAsFactors?
dt[, "ID", with=FALSE] <- as.character(dt[, "ID", with=FALSE]) 
#Produces error: Error in `[<-.data.table`(`*tmp*`, , "ID", with = FALSE, value = "c(1, 1, 1, 1, 1, 2, 2, 2, 2, 2)") : 
#unused argument(s) (with = FALSE)

我想念一些明显的东西吗?

由于Matthew的帖子更新:之前我使用过旧版本,但即使更新到1.6.6(我现在使用的版本)之后,我仍然会收到错误消息。

更新2:假设我想将类“factor”的每一列转换为“character”列,但事先不知道哪个列属于哪个类。 使用data.frame,我可以执行以下操作:

classes <- as.character(sapply(df, class))
colClasses <- which(classes=="factor")
df[, colClasses] <- sapply(df[, colClasses], as.character)

我可以用data.table做类似的事情吗?

更新3:

sessionInfo()       R版本2.13.1(2011-07-08)       平台:x86_64-pc-mingw32 / x64(64位)

locale:
[1] C

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] data.table_1.6.6

loaded via a namespace (and not attached):
[1] tools_2.13.1
trans by 2019-07-12T14:12:45Z

r - 在data.table中以递减顺序对data.table中的行进行排序`order(-x,v)`在data.table 1.9.4或earli上给出错误

让我们说DT[order(-x,v)]中有以下DT[order(-y,v)]

  library(data.table)
  DT = data.table(x=rep(c("b","a","c"),each=3), y=c(1,3,6), v=1:9)

我想通过两列(比如列DT[order(-y,v)]DT[order(-x,v)])订购它。 我用过这个:

 DT[order(x,v)] # sorts first by x then by v (both in ascending order)

但现在,我想按DT[order(-y,v)](按递减顺序)对其进行排序,并具有以下代码:

  DT[order(-x)] #Error in -x : invalid argument to unary operator

因此,我认为这个错误是由于DT[order(-y,v)]这个事实。你可以给我任何建议来解决这个问题吗?

我知道我可以使用DT[order(-y,v)],但我想知道使用两种方式(有些减少,有些增加)同时按几列排序的语法。

请注意,如果您使用DT[order(-y,v)],结果是正常的,但如果您使用DT[order(-x,v)]则会出错。 所以,我的问题是:如何解决这个错误?

trans by 2019-07-08T11:36:14Z

1 2 下一页 共2页