如何直接从列表内的所有嵌套列表中选择同一列？

问题描述 投票：0回答：3

是否可以直接选择列表中所有嵌套列表的某一列？
我的列表是使用aggregate()和table()创建的：

AgN=aggregate(data,by=list(d$date),FUN=table,useNA="no")


AgN$x
看起来像：

$`0`

      1           2           3           9          11 
0.447204969 0.438509317 0.096894410 0.009937888 0.007453416 

$`1`

          1           2           4           8          11 
0.489974937 0.389724311 0.102756892 0.006265664 0.011278195 

…

$n

我想获取每个表的特定列的向量，例如包含所有名为“1”的列的值的向量。 我仍然是一个 R 初学者，但即使经过长时间的搜索和尝试，我也没有找到好的解决方案。如果我想获取列表的字段，我可以简单地用括号对其进行索引，例如[i,j].
在网上我找到了一些矩阵的例子，所以我尝试做同样的事情，一开始只用 

AgN$x[1][1]
选择一个嵌套列表的列，但这仍然是选择整个列表：

$

0

     1           2           3           8          11

0.447204969 0.438509317 0.096894410 0.009937888 0.007453416

我的下一次尝试是

AgN$x[[1]][1]
，并且有效：

  1

0.447205

所以我尝试以同样的方式选择所有嵌套列表的每个第一列的值：

AgN$x[[1:length(AgN$x]][1]
Recursive indexing failed at level 2

问题显然是，如果使用双括号，则禁止选择范围。

我最后一次尝试是使用 for 循环：

cduR=NULL 
for (i in 1:length(AgN$x)){
t=AgN$x[[i]]
cduR=c(cduR,as.vector(t["1"]))
}

最后，到目前为止这似乎有效。但这样我每次想选择列时都必须构建一个循环。有没有直接的办法？

感谢您的帮助。

r nested-lists
3个回答
63
投票

假设您有类似以下内容：

myList <- list(`0` = c(`1` = 10, `2` = 20, `3` = 30, `4` = 72),
               `1` = c(`1` = 15, `2` = 9, `3` = 7))
myList
# $`0`
#  1  2  3  4 
# 10 20 30 72 
# 
# $`1`
#  1  2  3 
# 15  9  7

使用 

sapply()
或 
lapply()
进入您的列表并提取您想要的任何列。一些例子。

# As a list of one-column data.frames
lapply(myList, `[`, 1)
# $`0`
#  1 
# 10 
# 
# $`1`
#  1 
# 15 

# As a list of vectors
lapply(myList, `[[`, 1)
# $`0`
# [1] 10
# 
# $`1`
# [1] 15

# As a named vector
sapply(myList, `[[`, 1)
#  0  1 
# 10 15 

# As an unnamed vector
unname(sapply(myList, `[[`, 1))
# [1] 10 15

也可以帮助您实现这一点的其他语法变体包括：

## Same output as above, different syntax
lapply(myList, function(x) x[1])
lapply(myList, function(x) x[[1]])
sapply(myList, function(x) x[[1]])
unname(sapply(myList, function(x) x[[1]]))

A 嵌套列表示例

如果您有嵌套列表（列表中的列表），请尝试以下变体。

# An example nested list
myNestedList <- list(A = list(`0` = c(`1` = 10, `2` = 20, `3` = 30, `4` = 72),
                              `1` = c(`1` = 15, `2` = 9, `3` = 7)),
                     B = list(`0` = c(A = 11, B = 12, C = 13),
                              `1` = c(X = 14, Y = 15, Z = 16)))

# Run the following and see what you come up with....
lapply(unlist(myNestedList, recursive = FALSE), `[`, 1)
lapply(unlist(myNestedList, recursive = FALSE), `[[`, 1)
sapply(unlist(myNestedList, recursive = FALSE), `[[`, 1)
rapply(myNestedList, f=`[[`, ...=1, how="unlist")

请注意，对于

lapply()
和
sapply()
，您需要使用
unlist(..., recursive = FALSE)
，而对于
rapply()
（递归应用），您可以直接引用列表。

2
投票

我认为没有明确列出但也有效的一个例子是，如果您有一个带有行和列名称的 data.frames、matrix、xts、zoo 等列表，您可以随后返回整个行、列或集合以下语法：

列出以下格式的对象：

                           0%              1%             10%              50%              90%             99%            100%
Sec.1           -0.0005259283   -0.0002644018   -0.0001320010   -0.00005253342    0.00007852480    0.0002375756    0.0007870917
Sec.2           -0.0006620675   -0.0003931340   -0.0001588773   -0.00005251963    0.00007965378    0.0002121163    0.0004190017
Sec.4           -0.0006091183   -0.0003994136   -0.0001859032   -0.00005230263    0.00010592379    0.0003165986    0.0007870917
Sec.8           -0.0007679577   -0.0005321807   -0.0002636040   -0.00005232452    0.00014492480    0.0003930241    0.0007870917
Sec.16          -0.0009055318   -0.0007448356   -0.0003449334   -0.00005290166    0.00021238287    0.0004772207    0.0007870917
Sec.32          -0.0013007873   -0.0009552231   -0.0005243472   -0.00007836480    0.00028928104    0.0007382848    0.0013002350
Sec.64          -0.0016409500   -0.0012383696   -0.0006617173   -0.00005280668    0.00042354939    0.0011721508    0.0018579966
Sec.128         -0.0022575471   -0.0018858823   -0.0008466965   -0.00005298436    0.00068616576    0.0014665900    0.0027616991

代码（注意空的第一行索引，指定所有行）

simplify2array(lapply(listOfIdenticalObjects,`[`,,"50%"))

输出

                     ListItem1        ListItem2        ListItem3        ListItem4         ListItem5
Sec.1           -0.00005253342   -0.00004673443    -0.0001112780   -0.00001870960    -0.00002051009
Sec.2           -0.00005251963   -0.00004663200    -0.0001112904   -0.00001878075     0.00000000000
Sec.4           -0.00005230263   -0.00004669297    -0.0001112780   -0.00001869911    -0.00002034403
Sec.8           -0.00005232452   -0.00004663635    -0.0001111296   -0.00001926096     0.00000000000
Sec.16          -0.00005290166   -0.00004668207    -0.0001109570    0.00000000000     0.00000000000
Sec.32          -0.00007836480    0.00000000000    -0.0001111667   -0.00001894496     0.00000000000
Sec.64          -0.00005280668    0.00000000000    -0.0001110926   -0.00001878305     0.00000000000
Sec.128         -0.00005298436    0.00004675191     0.0000000000   -0.00005582568     0.00001020502
0
投票

这是使用 

purrr
包的 tidyverse 解决方案。 
map
和 
map_*
通常用于将函数应用于每个元素，但它们可以用作提取器（由 
pluck
语法提供支持）。当用作提取器时，如果元素为 
.default
或不存在（请参阅嵌套示例），您还可以指定 
NULL
参数来指定默认返回值（默认为 
NULL
）：

library(purrr)

# Flat list
myList <- list(`0` = c(`1` = 10, `2` = 20, `3` = 30, `4` = 72),
               `1` = c(`1` = 15, `2` = 9, `3` = 7))

map(myList, 3) # by index
map(myList, "3") # by name

# map_* variants to control output
map_int(myList, "3") # output integer vector


map_*
变体在这里起作用，因为每次提取都会返回一个长度为1的向量。如果此示例中的节点较长（而不是单个值），则会出错。

# Nested list
myNestedList <- list(A = list(`0` = c(`1` = 10, `2` = 20, `3` = 30, `4` = 72),
                              `1` = c(`1` = 15, `2` = 9, `3` = 7)),
                     B = list(`0` = c(A = 11, B = 12, C = 13),
                              `1` = c(X = 14, Y = 15, Z = 16)))

map_depth(myNestedList, -1, 4, .default = NA)
# $A
# $A$`0`
# [1] 72
# 
# $A$`1`
# [1] NA
# 
# 
# $B
# $B$`0`
# [1] NA
# 
# $B$`1`
# [1] NA

第二个值指定应进行提取的深度。负值将从列表的最低级别开始计数。

数据由@A5C1D2H2I1M1N2O1R2T1提供。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.