1

我有一些看起来像这样的数据：

 List_name     Condition1   Condition2  Situation1   Situation2
  List1          0.01         0.12         66           123
  List2          0.23         0.22         45           -34
  List3          0.32         0.23         13           -12
  List4          0.03         0.56         -3            45
  List5          0.56         0.05         12           100
  List6          0.90         0.09         22            32

我想根据截止值 0.5 过滤 data.frame 的每一列“条件”。过滤后，子集将出现，并将携带“情况”列的相应值。过滤器和子集将成对工作：“Condition1”与“Situation1”，“Condition2”与“Situation2”等等。

只是所需的输出： 

 List_name     Condition1     Situation1  List_name  Condition2  Situation2
  List1          0.01             66       List1        0.12        123
  List2          0.23             45       List2        0.22        -34
  List3          0.32             13       List3        0.23        -12
  List4          0.03             -3       List5        0.05        100
                                           List6        0.09         32

我很确定以前可能有另一种类似的情况，但我搜索了一下，没有找到。

4

3 回答 3

2

类似于优秀的@Arun 解决方案，但基于列名并且没有任何假设。

cols.conds <- colnames(dat)[gregexpr(pattern='Condition[0-9]+',colnames(dat)) > 0]
lapply(cols.conds, function(x){
   col.list <- colnames(dat)[1]
   col.situ <- gsub('Condition','Situation',x)
   dat[which(dat[[x]] < 0.5), c(col.list,x,col.situ)]}
)

我假设 dat 是：

dat <- read.table(text =' List_name     Condition1   Condition2  Situation1   Situation2
  List1          0.01         0.12         66           123
  List2          0.23         0.22         45           -34
  List3          0.32         0.23         13           -12
  List4          0.03         0.56         -3            45
  List5          0.56         0.05         12           100
  List6          0.90         0.02         22            32',head=T)
于 2013-02-12T15:29:49.433 回答
1

您可以使用布尔检查矢量化的概念：

x <- c(0.1, 0.3, 0.5, 0.2)
x < 0.5
# [1]  TRUE  TRUE FALSE  TRUE

还有一些grep结果：

grep('Condition', names(DF1))

要执行此子集，您可以使用它apply来生成布尔向量：

keepers <- apply(DF1[, grep('Condition', names(DF1))], 1, function(x) any(x < 0.5))

和子集：

DF1[keepers,]

请注意，这不一定会返回您在问题中显示的数据结构。all但是您可以使用或不同的阈值相应地更改匿名函数。

代替编辑，我会以不同的方式处理这个问题。我会melt从reshape2包中使用：

library(reshape2)
dat.c <- melt(DF1, 
              id.var='List_name', 
              measure.var=grep('Condition', names(DF1), value=TRUE),
              variable.name='condition',
              value.name='cond.val')
dat.c$idx <- gsub('Condition', '', dat.c$condition)
dat.s <- melt(DF1, 
              id.var='List_name', 
              measure.var=grep('Situation', names(DF1), value=TRUE),
              variable.name='situation',
              value.name='situ.val')
dat.s$idx <- gsub('Situation', '', dat.s$situation)
dat <- merge(dat.c, dat.s)

out <- dat[dat$cond.val < 0.5,]

   List_name idx  condition cond.val  situation situ.val
1      List1   1 Condition1     0.01 Situation1       66
2      List1   2 Condition2     0.12 Situation2      123
3      List2   1 Condition1     0.23 Situation1       45
4      List2   2 Condition2     0.22 Situation2      -34
5      List3   1 Condition1     0.32 Situation1       13
6      List3   2 Condition2     0.23 Situation2      -12
7      List4   1 Condition1     0.03 Situation1       -3
10     List5   2 Condition2     0.05 Situation2      100
12     List6   2 Condition2     0.09 Situation2       32

然后，您可以根据dcast需要将数据恢复为初始格式，但我发现这种“长”形式的数据更易于使用。这种形式也很令人愉快，因为它避免了对 NA 值的需要，其中您有满足一个条件而其他条件不满足的行。

out.c <- dcast(out, List_name ~ condition, value.var='cond.val')
out.s <- dcast(out, List_name ~ situation, value.var='situ.val')
merge(out.c, out.s)

  List_name Condition1 Condition2 Situation1 Situation2
1     List1       0.01       0.12         66        123
2     List2       0.23       0.22         45        -34
3     List3       0.32       0.23         13        -12
4     List4       0.03         NA         -3         NA
5     List5         NA       0.05         NA        100
6     List6         NA       0.09         NA         32
于 2013-02-12T15:31:08.220 回答
1

我认为您所要求的是可以实现的，但不能以bind您所展示的方式（绑定），因为它们具有不平等的元素。所以，你会得到一个清单。

在这里，我假设你的data.framealways 的形式是List_name，后跟 , ... 的列表Condition1，ConditionN然后Situation1是 , ..., SituationN。

然后，这可以通过获取第ids一个然后使用过滤来获得lapply

ids <- grep("Condition", names(df))
lapply(ids, function(x) df[which(df[[x]] < 0.5), c(1,x,x+length(ids))])

# [[1]]
#   List_name Condition1 Situation1
# 1     List1       0.01         66
# 2     List2       0.23         45
# 3     List3       0.32         13
# 4     List4       0.03         -3
# 
# [[2]]
#   List_name Condition2 Situation2
# 1     List1       0.12        123
# 2     List2       0.22        -34
# 3     List3       0.23        -12
# 5     List5       0.05        100
# 6     List6       0.09         32
于 2013-02-12T16:10:47.687 回答