虽然这是一个相当老的问题，但我必须说，它正好触及了我在R的第一步中所缺失的知识——即如何将我手中的数据表示为R中的对象，或者如何从现有的对象中进行选择。对于一个R新手来说，从一开始就“在R盒子里”思考并不容易。

所以我自己开始使用下面的拐杖，这帮助我找到什么对象使用什么数据，基本上想象现实世界的用法。

虽然我没有给出问题的确切答案，但下面的简短文本可能会帮助那些刚刚以R开头并提出类似问题的读者。

Atomic vector ... I called that "sequence" for myself, no direction, just sequence of same types. [ subsets. Vector ... the sequence with one direction from 2D, [ subsets. Matrix ... bunch of vectors with the same length forming rows or columns, [ subsets by rows and columns, or by sequence. Arrays ... layered matrices forming 3D Dataframe ... a 2D table like in excel, where I can sort, add or remove rows or columns or make arit. operations with them, only after some time I truly recognized that data frame is a clever implementation of list where I can subset using [ by rows and columns, but even using [[. List ... to help myself I thought about the list as of tree structure where [i] selects and returns whole branches and [[i]] returns item from the branch. And because it is tree like structure, you can even use an index sequence to address every single leaf on a very complex list using its [[index_vector]]. Lists can be simple or very complex and can mix together various types of objects into one.

所以对于列表，你可以根据情况选择更多的方法，就像下面的例子。

l <- list("aaa",5,list(1:3),LETTERS[1:4],matrix(1:9,3,3))
l[[c(5,4)]] # selects 4 from matrix using [[index_vector]] in list
l[[5]][4] # selects 4 from matrix using sequential index in matrix
l[[5]][1,2] # selects 4 from matrix using row and column in matrix

这种思维方式对我帮助很大。

虽然这是一个相当老的问题，但我必须说，它正好触及了我在R的第一步中所缺失的知识——即如何将我手中的数据表示为R中的对象，或者如何从现有的对象中进行选择。对于一个R新手来说，从一开始就“在R盒子里”思考并不容易。

所以我自己开始使用下面的拐杖，这帮助我找到什么对象使用什么数据，基本上想象现实世界的用法。

虽然我没有给出问题的确切答案，但下面的简短文本可能会帮助那些刚刚以R开头并提出类似问题的读者。

Atomic vector ... I called that "sequence" for myself, no direction, just sequence of same types. [ subsets. Vector ... the sequence with one direction from 2D, [ subsets. Matrix ... bunch of vectors with the same length forming rows or columns, [ subsets by rows and columns, or by sequence. Arrays ... layered matrices forming 3D Dataframe ... a 2D table like in excel, where I can sort, add or remove rows or columns or make arit. operations with them, only after some time I truly recognized that data frame is a clever implementation of list where I can subset using [ by rows and columns, but even using [[. List ... to help myself I thought about the list as of tree structure where [i] selects and returns whole branches and [[i]] returns item from the branch. And because it is tree like structure, you can even use an index sequence to address every single leaf on a very complex list using its [[index_vector]]. Lists can be simple or very complex and can mix together various types of objects into one.

所以对于列表，你可以根据情况选择更多的方法，就像下面的例子。

l <- list("aaa",5,list(1:3),LETTERS[1:4],matrix(1:9,3,3))
l[[c(5,4)]] # selects 4 from matrix using [[index_vector]] in list
l[[5]][4] # selects 4 from matrix using sequential index in matrix
l[[5]][1,2] # selects 4 from matrix using row and column in matrix

这种思维方式对我帮助很大。

你可以试试，

set.seed(123)
l <- replicate(20, runif(sample(1:10,1)), simplify = FALSE)

out <- vector("list", length(l))
for (i in seq_along(l)) {
  out[[i]] <- length(unique(l[[i]])) #length(l[[i]])
}
unlist(out)

unlist(lapply(l,length))
unlist(lapply(l, class))
unlist(lapply(l, mean))
unlist(lapply(l, max))

只是为了解决你问题的最后一部分，因为这确实指出了R中列表和向量之间的区别:

为什么这两个表达式不返回相同的结果? X = list(1,2,3,4);X2 = list(1:4)

列表可以包含任何其他类作为每个元素。所以你可以有一个列表，其中第一个元素是一个字符向量，第二个是一个数据帧，等等。在本例中，您创建了两个不同的列表。X有四个向量，每个向量的长度都是1。X2有一个长度为4的向量:

> length(x[[1]])
[1] 1
> length(x2[[1]])
[1] 4

这是完全不同的列表。

R列表非常类似于哈希映射数据结构，因为每个索引值都可以与任何对象相关联。下面是一个简单的列表示例，它包含3个不同的类(包括一个函数):

> complicated.list <- list("a"=1:4, "b"=1:3, "c"=matrix(1:4, nrow=2), "d"=search)
> lapply(complicated.list, class)
$a
[1] "integer"
$b
[1] "integer"
$c
[1] "matrix"
$d
[1] "function"

假设最后一个元素是搜索函数，我可以这样调用它:

> complicated.list[["d"]]()
[1] ".GlobalEnv" ...

作为最后的评论:应该注意data.frame实际上是一个列表(来自data.frame文档):

数据帧是一组行数相同且行名唯一的变量，给定类"data.frame"

这就是为什么data.frame中的列可以有不同的数据类型，而矩阵中的列则不能。举个例子，在这里我尝试用数字和字符创建一个矩阵:

> a <- 1:4
> class(a)
[1] "integer"
> b <- c("a","b","c","d")
> d <- cbind(a, b)
> d
 a   b  
[1,] "1" "a"
[2,] "2" "b"
[3,] "3" "c"
[4,] "4" "d"
> class(d[,1])
[1] "character"

请注意，我无法将第一列的数据类型更改为数字，因为第二列有字符:

> d[,1] <- as.numeric(d[,1])
> class(d[,1])
[1] "character"

关于其他语言中的向量和哈希/数组概念:

Vectors are the atoms of R. Eg, rpois(1e4,5) (5 random numbers), numeric(55) (length-55 zero vector over doubles), and character(12) (12 empty strings), are all "basic". Either lists or vectors can have names. > n = numeric(10) > n [1] 0 0 0 0 0 0 0 0 0 0 > names(n) NULL > names(n) = LETTERS[1:10] > n A B C D E F G H I J 0 0 0 0 0 0 0 0 0 0 Vectors require everything to be the same data type. Watch this: > i = integer(5) > v = c(n,i) > v A B C D E F G H I J 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 > class(v) [1] "numeric" > i = complex(5) > v = c(n,i) > class(v) [1] "complex" > v A B C D E F G H I J 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i Lists can contain varying data types, as seen in other answers and the OP's question itself.

我见过一些语言(ruby, javascript)，其中的“数组”可能包含变量数据类型，但例如在c++中，“数组”必须是相同的数据类型。我相信这是一个速度/效率的问题:如果你有一个数字(1e6)，你可以先验地知道它的大小和每个元素的位置;如果某个未知片段中可能包含“紫飞食人”，那么你就必须真正分析这些内容来了解它的基本事实。

当类型得到保证时，某些标准R操作也更有意义。例如cumsum(1:9)是有意义的，而cumsum(list(1,2,3,4,5，'a'，6,7,8,9)则没有意义，因为不能保证类型为double。

关于你的第二个问题:

即使在调用函数时从未传入List，也可以从函数返回List

函数返回的数据类型总是与输入的数据类型不同。Plot返回一个Plot，即使它不接受一个Plot作为输入。Arg返回一个数字，即使它接受了复数。等。

(至于strsplit:源代码在这里。)

再补充一点:

R在散列包中确实有一个与Python dict等效的数据结构。你可以在这篇来自开放数据组的博客文章中读到它。这里有一个简单的例子:

> library(hash)
> h <- hash( keys=c('foo','bar','baz'), values=1:3 )
> h[c('foo','bar')]
<hash> containing 2 key-value pairs.
  bar : 2
  foo : 1

就可用性而言，哈希类非常类似于列表。但对于大型数据集，性能更好。