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

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:源代码在这里。)

你说:

另一方面，可以返回列表 从函数中 调用时传入一个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做同样的事情呢?

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

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:源代码在这里。)

x = list(1, 2, 3, 4)
x2 = list(1:4)
all.equal(x,x2)

不一样，因为1:4等于c(1,2,3,4) 如果你想让它们相同，那么:

x = list(c(1,2,3,4))
x2 = list(1:4)
all.equal(x,x2)

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

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

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

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

x3 = as.list(1:4)

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

这是一个非常老的问题，但我认为一个新的答案可能会增加一些价值，因为在我看来，没有人直接解决OP中的一些问题。

不管接受的答案是什么，R中的列表对象不是哈希映射。如果你想与python并行，列表更像是python列表(实际上是元组)。

最好描述大多数R对象是如何内部存储的(R对象的C类型是SEXP)。它们主要由三部分组成:

一个头，声明对象的R类型，长度和其他一些元数据; 数据部分，这是一个标准的C堆分配数组(连续的内存块); 属性，它是指向其他R对象的指针的命名链表(如果对象没有属性，则为NULL)。

从内部的角度来看，例如，列表和数字向量之间几乎没有区别。它们存储的值是不同的。让我们把两个对象分解到之前描述的范例中:

x <- runif(10)
y <- list(runif(10), runif(3))

x:

头文件会说类型是数字(c端是REALSXP)，长度是10等等。 数据部分将是一个包含10个双精度值的数组。 属性为NULL，因为对象没有任何属性。

y:

头文件会说类型是list (c端是VECSXP)，长度是2等等。 数据部分将是一个包含两个指向两种SEXP类型的指针的数组，分别指向由runif(10)和runif(3)获得的值。 属性是NULL，就像x一样。

所以数字向量和列表之间的唯一区别是数字数据部分由双值组成，而对于列表，数据部分是指向其他R对象的指针数组。

名字会怎么样呢?名字只是你可以分配给对象的一些属性。让我们看看下面的对象:

z <- list(a=1:3, b=LETTERS)

头文件会说类型是list (c端是VECSXP)，长度是2等等。 数据部分将是一个数组，包含2个指向两种SEXP类型的指针，分别指向通过1:3和字母获得的值。 属性现在出现了，是一个名称组件，它是一个字符R对象，值为c("a"，"b")。

在R级别，您可以使用attributes函数检索对象的属性。

R中典型哈希映射的键-值只是一种假象。当你说:

z[["a"]]

事情是这样的:

the [[ subset function is called; the argument of the function ("a") is of type character, so the method is instructed to search such value from the names attribute (if present) of the object z; if the names attribute isn't there, NULL is returned; if present, the "a" value is searched in it. If "a" is not a name of the object, NULL is returned; if present, the position of the first occurence is determined (1 in the example). So the first element of the list is returned, i.e. the equivalent of z[[1]].

键值搜索是相当间接的，并且总是位置搜索。另外，记住:

在哈希映射中，键必须具有的唯一限制是它必须是可哈希的。R中的名称必须是字符串(字符向量); 在哈希映射中，不能有两个相同的键。在R中，你可以用重复的值给一个对象分配名称。例如: name (y) <- c("same"， "same")

在r中完全有效。当您尝试y[["same"]]时，会检索到第一个值。现在你应该知道原因了。

总之，给对象赋予任意属性的能力会让您从外部角度看到不同的外观。但是R列表并不是哈希映射。