列表之所以能够(有序地)工作，原因之一是为了满足对有序容器的需求，该容器可以在任何节点上包含任何类型，而向量不能做到这一点。在R中，列表被重用用于各种目的，包括形成data.frame的基，这是一个任意类型(但长度相同)的向量列表。

为什么这两个表达式不返回相同的结果?

x = list(1, 2, 3, 4); x2 = list(1:4)

给@Shane的答案加上一点，如果你想得到同样的结果，试试:

x3 = as.list(1:4)

它将1:4的向量强制转换为一个列表。

你可以试试，

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"

为什么这两个不同的操作符[]和[[]]返回相同的结果?

x = list(1, 2, 3, 4)

[ ] provides sub setting operation. In general sub set of any object will have the same type as the original object. Therefore, x[1] provides a list. Similarly x[1:2] is a subset of original list, therefore it is a list. Ex. x[1:2] [[1]] [1] 1 [[2]] [1] 2 [[ ]] is for extracting an element from the list. x[[1]] is valid and extract the first element from the list. x[[1:2]] is not valid as [[ ]] does not provide sub setting like [ ]. x[[2]] [1] 2 > x[[2:3]] Error in x[[2:3]] : subscript out of bounds

列表之所以能够(有序地)工作，原因之一是为了满足对有序容器的需求，该容器可以在任何节点上包含任何类型，而向量不能做到这一点。在R中，列表被重用用于各种目的，包括形成data.frame的基，这是一个任意类型(但长度相同)的向量列表。

为什么这两个表达式不返回相同的结果?

x = list(1, 2, 3, 4); x2 = list(1:4)

给@Shane的答案加上一点，如果你想得到同样的结果，试试:

x3 = as.list(1:4)

它将1:4的向量强制转换为一个列表。

你说:

另一方面，可以返回列表 从函数中 调用时传入一个List 函数，即使函数 不包含List构造函数， 例如,

x = strsplit(LETTERS[1:10], "") # passing in an object of type 'character'
class(x)
# => 'list'

我猜你认为这是个问题(?)我在这里告诉你为什么这不是问题:-)。您的示例有点简单，因为当您执行字符串拆分时，您拥有一个包含1个元素的列表，因此您知道x[[1]]与unlist(x)[1]相同。但是如果strsplit的结果在每个bin中返回不同长度的结果呢?简单地返回一个向量(而不是一个列表)根本不行。

例如:

stuff <- c("You, me, and dupree",  "You me, and dupree",
           "He ran away, but not very far, and not very fast")
x <- strsplit(stuff, ",")
xx <- unlist(strsplit(stuff, ","))

在第一种情况下(x:返回一个列表)，您可以告诉第三个字符串的第二个“部分”是什么，例如:x[[3]][2]。既然结果已经“解开”(未列出)，您如何使用xx做同样的事情呢?