zoukankan      html  css  js  c++  java
  • 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.

  • 相关阅读:
    ORACLE EBS中查看某个Request的Output File
    如何查看非自己提交的请求的结果
    ORACLE EBS中OAF屏蔽的错误
    对OAF开发中的MDS的初步研究(转)
    MapGuide应用最佳实践资源库Repository的维护
    MapGuide OpenSource 2.1在Windows 7上运行
    MapGuide应用最佳实践采用托管(Managed)资源还是非托管(Unmanaged)资源
    MapGuide Open Source 2.1 正式发布
    Autodesk 2009开发者日现在开始报名
    支持Windows 7的CAD—AutoCAD Civil 3D 2010
  • 原文地址:https://www.cnblogs.com/aipeli/p/6275712.html
Copyright © 2011-2022 走看看