R语言编程艺术#03#列表，list
向量的元素要求都是同类型的，而列表（list）与向量不同，可以组合多个不同类型的对象。类似于C语言中的结构体（struct）类型。
1、创建列表
从技术上讲，列表就是向理。之前我们接触过的普通向量都称为“原子型”（atomic）向量，就是说，向量的元素已经是最小的、不可再分的。而列表则属于“递归型”（recursive）向量。
以一个雇员数据库作为第一个例子。对于每个雇员，我们存储其姓名、工资，以及一个布尔变量，表示是否工会成员。这三个变量有三个不同的类型：字符串、数值
> j <- list(name="joe", salary=55000,union=T) > j $name [1] "joe" $salary [1] 55000 $union [1] TRUE >
R语言中列表各个组件的名称叫做标签（tags），如上面的代码salary。实际上标签是可选的，也可以不指定。如下：
> jalt <- list("joe",5500,T)
> jalt
[[1]]
[1] "joe"
[[2]]
[1] 5500
[[3]]
[1] TRUE
>但一般来说都会给各个部分取名，而不使用这些默认的数值，这样使代码更清晰而且不容易犯错误，在使用的时候，标签的名字可以简写，只写出前几个字母，只要不引起歧议，R都能识别：
> j $name [1] "joe" $salary [1] 55000 $union [1] TRUE > j$sal [1] 55000 >
因为列表是向理，因此可以用vector（）来创建列表。
> z <- vector(mode = "list") > z list() > z[["abc"]] <- 3 > z $abc [1] 3 >
2、列表的常规操作
#列表索引 （访问列表的组件有很多种方法）返回值是c的数据类型
> j$name [1] "joe" > j[["name"]] [1] "joe" > j[[1]] [1] "joe" >
使用单中括号和双重中括号都可以提取列表的元素，但是与普通（原子型）向量索引相比，两者存在很大的不同。使用单中括号[]返回的是一个新的列表，它是原列表的子列表。
> j[1:2] $name [1] "joe" $salary [1] 55000 > j2 <- j[2] > j2 $salary [1] 55000 > class(j2) [1] "list" > str(j2) List of 1 $ salary: num 55000 >
对原列表的取子集操作返回一个新的列表，新的列表由原列表的前两个元素组成。这里说“返回”是因为中括号也是一个函数。就类似于“+”这种操作符，看起来不像函数，但实际上是函数。
而双重中括号“[[]]”一次只能提取列表的一个组件，返回值是组件本身的类型，而不是列表。
> j[[1:2]] Error in j[[1:2]] : subscript out of bounds > j2a <- j[[2]] > j2a [1] 55000 > class(j2a) [1] "numeric" >
#增加或删除列表元素
很多情况下，需要增加和删除元素，尤其是涉及由列表组成的数据类型时，比如数据框和R中的类（class）。
>#增加新的元素 > z <- list(a="abc",b=12) > z $a [1] "abc" $b [1] 12 > z$c <- "sailing" #增加新的组件 > z $a [1] "abc" $b [1] 12 $c [1] "sailing" >
使用索引增加元素
> z $a [1] "abc" $b [1] 12 $c [1] "sailing" > z[[4]] <-28 > z $a [1] "abc" $b [1] 12 $c [1] "sailing" [[4]] [1] 28 > z[5:7] <- c(FALSE,TRUE,TRUE) > z $a [1] "abc" $b [1] 12 $c [1] "sailing" [[4]] [1] 28 [[5]] [1] FALSE [[6]] [1] TRUE [[7]] [1] TRUE >
删除列表元素，直接将元素NULL就可以了
> z $a [1] "abc" $b [1] 12 $c [1] "sailing" [[4]] [1] 28 [[5]] [1] FALSE [[6]] [1] TRUE [[7]] [1] TRUE > z[[2]] <- NULL > z $a [1] "abc" $c [1] "sailing" [[3]] [1] 28 [[4]] [1] FALSE [[5]] [1] TRUE [[6]] [1] TRUE
删除z$b之后，它之后的元素索引全部减1，如原来的z[[4]]变成了z[[3]]。还可以把多个列表拼接成一个。
> c(list("joe",55000,T),list(5))
[[1]]
[1] "joe"
[[2]]
[1] 55000
[[3]]
[1] TRUE
[[4]]
[1] 5#获取列表长度
> j $name [1] "joe" $salary [1] 55000 $union [1] TRUE > length(j) [1] 3 >
3、访问列表元素和值
如果一个列表和各个元素含有标签，就可以使用names（）获取它的标签
> names(j) [1] "name" "salary" "union"
还可以使用unlist()函数获取列表的值
> ulj <- unlist(j) > ulj name salary union "joe" "55000" "TRUE" > class(ulj) [1] "character"
unlist()返回值是一个向量，在本例中是一个字符向量。而且向量的元素名就来自原列表的标签。若列表内都是数值，哪么unlist()返回的也就是数值向量，若列表内是字符与数值混合，哪unlist()返回的是字符类型的向量。
> ulj <- unlist(j)
> ulj
name salary union
"joe" "55000" "TRUE"
> class
function (x) .Primitive("class")
> class(ulj)
[1] "character"各种类型的优先级排序是：
NULL<raw<逻辑类型<整型<实数类型<复数类型<列表<表达式(把配对列表（pairlist）当作普通列表)
去除元素的名称的方法如下：
>#方法一
> wu <- list(a=5,b="xyz") > names(wu) <-NULL > wu [[1]] [1] 5 [[2]] [1] "xyz" >#方法二 > wu <- list(a=5,b="xyz") > wu $a [1] 5 $b [1] "xyz" > wu <- unname(wu) > wu [[1]] [1] 5 [[2]] [1] "xyz"
4、在列表上使用apply系列函数
使用lapply()和sapply()这两个函数，可以很方便地在列表上应用函数。
#lapply()和sapply()的使用
lapply()代表list apply，与矩阵的apply()函数的用法相似，对列表（或强制转换成列表的向量）的每个组件执行给定的函数，并返回另一个列表。
> lapply(list(1:3,25:29),median) [[1]] [1] 2 [[2]] [1] 27
R分别对1：3和25：29求中位数，返回由2，27组成的列表。
如果想得到lapply()返回的列表可以转化为矩阵或向量的形式，这时候可以选择使用sapply()代表simplified lapply）：
> sapply(list(1:3,25:29),median) [1] 2 27
在以上的例子中，我们在一个向量上执行一个向量化的函数，返回一个新的向量，然后将向量整理成矩阵的形式。如果使用sapply()函数就可以直接输出矩阵。
5、递归型列表
列表可以是递归的（recursive)，即列表的组件也可以是列表。
> b <-list(u=5, v= 12) > c <-list(w = 13) > a <-list(b,c) > a [[1]] [[1]]$u [1] 5 [[1]]$v [1] 12 [[2]] [[2]]$w [1] 13 > length(a) [1] 2
这段代码生成一个包含两个组件的列表，每个组件本身也都是列表。
> c(list(a=1,b=2,c=list(d=5,e=9))) $a [1] 1 $b [1] 2 $c $c$d [1] 5 $c$e [1] 9 > c(list(a=1,b=2,c=list(d=5,e=9)),recursive=T) a b c.d c.e 1 2 5 9 >
拼接函数c()有一个可选参数recursive，决定在拼接列表的时候，是否把原列“压平”，就是把所有组件的元素都提取出来，组合成一个向量。
第一条命令中，recursive参数取黙认值FALSE，得一个递归型列表，其中组件c是另一个列表。
第二条命令中，recursive参数值为TRUE，得到一个向量（也可以说是列表），只有名称还带有原来递归的特征。（注意recursive参数为TRUE反而得到非递归的列表，不要弄混）
end.
