R语言编程艺术#03#列表（list）

最新推荐文章于 2021-09-27 19:10:04 发布

weixin_34227447

最新推荐文章于 2021-09-27 19:10:04 发布

阅读量298

点赞数

文章标签： r语言数据库 c/c++

向量的元素要求都是同类型的，而列表（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.