R语言数据结构-----列表

简介: R语言数据结构-----列表

列表的基本操作


> x<-list(u=2,v="abc")
> x
$u
[1] 2
$v
[1] "abc"
> x$u
[1] 2
函数hist()中的数据,也是通过列表保存的
> hn<-hist(Nile)
> print(hn)
$breaks
 [1]  400  500  600  700  800  900 1000 1100 1200 1300 1400
$counts
 [1]  1  0  5 20 25 19 12 11  6  1
$density
 [1] 0.0001 0.0000 0.0005 0.0020 0.0025 0.0019 0.0012 0.0011 0.0006
[10] 0.0001
$mids
 [1]  450  550  650  750  850  950 1050 1150 1250 1350
$xname
[1] "Nile"
$equidist
[1] TRUE
attr(,"class")
[1] "histogram"
#也可以用
> str(hn)
List of 6
 $ breaks  : int [1:11] 400 500 600 700 800 900 1000 1100 1200 1300 ...
 $ counts  : int [1:10] 1 0 5 20 25 19 12 11 6 1
 $ density : num [1:10] 0.0001 0 0.0005 0.002 0.0025 0.0019 0.0012 0.0011 0.0006 0.0001
 $ mids    : num [1:10] 450 550 650 750 850 950 1050 1150 1250 1350
 $ xname   : chr "Nile"
 $ equidist: logi TRUE
 - attr(*, "class")= chr "histogram"

(1)创建列表

#列表中各组件的名称叫标签
> j<-list(name="Joe",salary=55000,union=T)
> j
$name
[1] "Joe"
$salary
[1] 55000
$union
[1] TRUE
#标签是可选的,也可以不指定
> jalt<-list("Joe",55000,T)
> jalt
[[1]]
[1] "Joe"
[[2]]
[1] 55000
[[3]]
[1] TRUE
#但是一般来说推荐为各个部分取名而不用默认的数值,这样使得代码更加清晰
#在使用时可以使用简称,只要不引起歧义
> j$sal
[1] 55000
#因为列表是向量,所以可以用vector()创建列表
> z[["abc"]]<-3
> z
$abc
[1] 3


(2)列表索引

> j$salary
[1] 55000
> j[["salary"]]
[1] 55000
#可以用数字索引访问列表中的组件,但是要用双重中括号
> j[[2]]
[1] 55000
[]用于提取子集:[]可以用来提取数据结构中的一个或多个元素,并返回一个与原始结构类型相匹配的新结构
> j[2]
$salary
[1] 55000
[[]]用于提取单个元素或子列表:[[]]一次只能提取列表的一个组件,返回值是组件本身的类型,而不是列表
> j[[2]]
[1] 55000
#只能提取列表中的一个组件
> j[[1:2]]
Error in j[[1:2]] : subscript out of bounds
> j2a<-j[[2]]
> j2a
[1] 55000
> class(j2a)
[1] "numeric"
> j[1:2]
$name
[1] "Joe"
$salary
[1] 55000
> class(j2)
[1] "list"
> str(j2)
List of 1
 $ salary: num 55000


(3)增加或删除列表元素

添加新的组件

> 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<-list(a="abc",b=12)
> z[[4]]<-28
> z[5:7]<-c(FALSE,TRUE,TRUE)
> z
$a
[1] "abc"
$b
[1] 12
[[3]]
NULL
[[4]]
[1] 28
[[5]]
[1] FALSE
[[6]]
[1] TRUE
[[7]]
[1] TRUE
删除列表元素可以直接把它的值设为NULL
#删除z$b之后,它之后的元素索引全部减1,例如原来的z[[4]]变成了z[[3]]
> z$b<-NULL
> z
$a
[1] "abc"
[[2]]
NULL
[[3]]
[1] 28
[[4]]
[1] FALSE
[[5]]
[1] TRUE
[[6]]
[1] TRUE
#把多个列表拼接成一个
> c(list("Joe","55000",T),list(5))
[[1]]
[1] "Joe"
[[2]]
[1] "55000"
[[3]]
[1] TRUE
[[4]]
[1] 5
获取列表长度
> length(j)
[1] 3

(4)访问列表元素和值

如果一个列表的各元素含有标签,就可以使用names()获取它的标签
#如果一个列表的各元素含有标签,就可以使用names()获取它的标签
> names(j)
[1] "name"   "salary" "union" 
#使用unlist()来获取列表的值
#unlist()返回的值是一个向量---这里返回的是一个字符串向量,而且向量的元素名就来自原列表的标签
> ulj<-unlist(j)
> ulj
   name  salary   union 
  "Joe" "55000"  "TRUE" 
> class(ulj)
[1] "character"
#如果列表中都是数值,unlist()返回的就是数值向量
> z<-list(a=5,b=12,c=13)
> y<-unlist(z)
> class(y)
[1] "numeric"
> y
 a  b  c 
 5 12 13 
#如果列表中既有字符串又有数值
#混合类型的数值下R选择了这些类型中能最大程度地保留它们共同特性的类型:字符串
#各种类型的优先级排序
NULL<raw<逻辑类型<整型<实数类型<复数类型<列表<表达式
> w<-list(a=5,b="xyz")
> wu<-unlist(w)
> class(wu)
[1] "character"
> wu
    a     b 
  "5" "xyz" 
重点
#各种类型的优先级排序
NULL<raw<逻辑类型<整型<实数类型<复数类型<列表<表达式
 如果把向量元素名称赋值为NULL,可以将其移除
> x<-c(1,2,4)
> names(x)
NULL
> names(x)<-c("a","b","ab")
> names(x)
[1] "a"  "b"  "ab"
> x
 a  b ab 
 1  2  4 
#把向量元素名称赋值为NULL,可以将其移除
> names(x)<-NULL
> x
[1] 1 2 4
#用名称来引用向量中的元素
> x<-c(1,2,4)
> names(x)<-c("a","b","ab")
> x["b"]
b 
> w<-list(a=5,b="xyz")
> wu<-unlist(w)
> names(wu)<-NULL
> wu
[1] "5"   "xyz"
#unname()函数直接去掉元素名
> wun<-unname(wu)
> wun
[1] "5"   "xyz"


(5)apply()函数

lapply()(代表list apply)与矩阵的apply()函数相似,对列表的每个组件执行特定的函数
并返回另外一个列表
> lapply(list(1:3,25:29),median)
[[1]]
[1] 2
[[2]]
[1] 27
 lapply()返回的列表可以转化为矩阵或向量的形式
sapply()(代表simplified[l]apply)
> sapply(list(1:3,25:29), median)
[1]  2 27
> z<-function(z)
+ return (c(z,z^2))
> sapply(1:8,z)
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,]    1    2    3    4    5    6    7    8
[2,]    1    4    9   16   25   36   49   64

(6)递归型列表

#生成包含两个组件的列表,每个组件本事都是列表
> 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
#recursive默认为FALSE,得到一个递归型列表,其中组件c是另外一个列表
#recursive=TRUE,得到的是向量,只有名称还带有原来递归的特征
> c(list(a=1,b=2,c=list(d=5,e=9)),recursive=T)
  a   b c.d c.e 
  1   2   5   9
目录
相关文章
|
1月前
|
存储 NoSQL Redis
Redis常见面试题:ZSet底层数据结构,SDS、压缩列表ZipList、跳表SkipList
String类型底层数据结构,List类型全面解析,ZSet底层数据结构;简单动态字符串SDS、压缩列表ZipList、哈希表、跳表SkipList、整数数组IntSet
|
2月前
|
存储 索引 Python
python数据结构之列表详解
列表是Python中极为灵活和强大的数据结构,适合于存储和操作有序数据集合。掌握其基本操作和高级特性对于编写高效、清晰的Python代码至关重要。通过本回答,希望能帮助你全面理解Python列表的使用方法,从而在实际编程中更加游刃有余。
31 0
|
3月前
|
存储 索引 Python
Python编程的常用数据结构—列表
Python编程的常用数据结构—列表
21 0
|
3月前
|
存储 索引 Python
Python编程的常用数据结构—列表 原创
Python编程的常用数据结构—列表 原创
22 0
|
5月前
|
存储 缓存 Python
Python中的列表(List)和元组(Tuple)是两种重要的数据结构
【7月更文挑战第12天】Python中的列表(List)和元组(Tuple)是两种重要的数据结构
59 1
|
6月前
|
存储 Python
Python中使用列表和字典来存储和处理复杂的数据结构
Python中使用列表和字典来存储和处理复杂的数据结构
|
6月前
|
存储 索引 Python
Python零基础入门-5 数据结构(列表和元组
Python零基础入门-5 数据结构(列表和元组
|
7月前
|
数据处理 Python
深入理解Python的数据结构:列表与元组
深入理解Python的数据结构:列表与元组
47 1
|
7月前
|
BI 索引
R语言数据结构-----向量
R语言数据结构-----向量
33 4
|
7月前
|
索引
R语言中的数据结构----矩阵
R语言中的数据结构----矩阵
54 3