R语言-数据类型、结构以及对象类型1

R语⾔-数据类型、结构以及对象类型1
R语⾔-数据类型|数据结构|对象类型
⽬录
 1. 数据类型
 2. 数据结构
 3. 对象类型
1. 数据类型
向量的类型：mode()返回的结果
logical（逻辑型）
numeric（数值型）
complex（复数型）
character（字符型）
其中
integer 和 double 在mode() 时返回的都是 numeric
factor 在 mode() 时返回的也是 numeric
其它类型
list
S4
检验对象的类型
is.logical()
is.numeric()
is.integer()
is.double()
is.factor()
plex()
is.character()
强制转换
as.logical()
as.numeric()
-- as.integer()
-- as.double()
-- as.factor()
plex()
as.character()
R特殊值数据
# 为确保所有数据都能被正确识别、计算或统计等，R定义了⼀些特殊值数据：
NULL：空数据
NA：表⽰⽆数据
NaN：表⽰⾮数字
inf：数字除以0得到的值
# 判断⼀个object （x）是不是属于这些类型有相应的函数：
is.null(x)
is.na(x)
is.nan(x)
is.infinite(x)
R中获取数据类型信息的⼀些有⽤函数
R语⾔的对象“类”很多，虽然我们不可能⼀⼀去详细学习，但接触到⼀类新数据时我们需要了解⼀些基本信息才能进⾏进⼀步的操作。

R 提供了⼀些⾮常有⽤的⽅法（函数）。

getClass( )函数我们前⾯已经见过了，它的参数是表⽰类的字符串。

class( )可获取⼀个数据对象所属的类，它的参数是对象名称。

str( )可获取数据对象的结构组成，这很有⽤。

mode( )和storage.mode( )可获取对象的存储模式。

2. 数据结构
R中的数据结构主要⾯向《线性代数》中的⼀些概念，如向量、矩阵等。

值得注意的是，R中其实没有简单数据（数值型、逻辑型、字符型等），对于简单类型会⾃动看做长度为1的向量。

⽐如：
> b <- 5
> length(b)
[1] 1
> typeof(b)
[1] "double"
> mode(b)
[1] "numeric"
R中最重要的数据结构是向量(vector)和矩阵(matrix)。

向量由⼀系列类型相同的有序元素构成；矩阵是数组(array)的⼀个特例：维数为2的数组；⽽数组⼜是增加了维度（dim）属性的向量。

除此之外，列表（list）和数据框（data frame）分别是向量和矩阵的泛化——列表允许包含不同类型的元素，甚⾄可以把对象作为元素；数据框允许每列使⽤不同类型的元素。

对于列表和数据框，其中的元素通常称为分量（components）。

3. 对象类型
对象的类型和长度
R中所有的对象都有类型和长度属性，可以通过函数typeof()和length()获取/设置。

> x = c(1,2,3,4)
> x
[1] 1 2 3 4
> typeof(x)
[1] "double"
> length(x)
[1] 4
> dim(x)=c(2,2)
> x
[,1] [,2]
[1,] 1 3
[2,] 2 4
> typeof(x)
[1] "double"
> length(x)
[1] 4
> Lst <- list(name="Fred", wife="Mary", no.children=3, child.ages=c(4,7,9))
>
> Lst
$name
[1] "Fred"
$wife
[1] "Mary"
$no.children
[1] 3
$child.ages
[1] 4 7 9
> typeof(Lst)
[1] "list"
> length(Lst)
[1] 4
对象的类型不是⼀成不变的，可以随时进⾏转换。

接着上⾯的例⼦：
> typeof(x)
[1] "double"
> y = as.logical(x)
> typeof(y)
[1] "logical"
转换的规则如下表：
不同数据类型间的转换
---to numeric to logical to character
to logical
FALSE → 0 | TRUE → 1-TRUE → "TRUE" | FALSE →"FALSE"to
character "1", "2", ... → 1, 2, ... "A",...→NA "FALSE", "F" → FALSE | "TRUE", "T" → TRUE | 其它 →NA
- 对象的长度也可以随时发⽣改变，常见的包括如下情况：
> # 扩⼤索引范围
> x = c(1,2,3)
> x
[1] 1 2 3
> x[5] = 12
> x
[1] 1 2 3 NA 12
> length(x)
[1] 5
> # 直接设置length 属性
> length(x) = 2
> x
[1] 1 2
> # 重新赋值（略）
• ✓ 对象的class 和attributes
typeof()处理对象内元素的类型，⽽class()处理对象本⾝的类，例如：
> x = 1:6
> x
[1] 1 2 3 4 5 6
> typeof(x)
[1] "integer"
> class(x)
[1] "integer"
> dim(x) = c(3,2)
> x
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
> typeof(x)
[1] "integer"
> class(x)
[1] "matrix"
通过class 还可以更改对象的类，例如：
> x = 1:6
> class(x)
[1] "integer"
> class(x) = "matrix"
# 错误于class(x) = "matrix" : 除⾮维度的长度为⼆(⽬前是0)，否则不能设为矩阵类别
> class(x) = "logical"
> x
[1] TRUE TRUE TRUE TRUE TRUE TRUE
除了typeof 和length 之外，其他class 的对象可能还会有其他的属性，可以通过函数attributes()和attr()进⾏操作，例如：
> x = 1:6
> attributes(x)
NULL
> dim(x) = c(3,2)
> attributes(x)
$dim
[1] 3 2
> x
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
> attr(x,"dim") = c(2,3)
> x
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
# 从例⼦可以看出，属性以列表形式保存，其中所有元素都有名字。

# 从例⼦还可以看出，R 的数组中，元素的排列顺序是第⼀下标变化最快，最后下标变化最慢。

这在FORTRAN 中叫做 “按列次序”。

⼀些常见的属性如下：
names ，可以为向量或列表的每个元素增加标签。

> x = 1:6
[1] 1 2 3 4 5 6
> attributes(x)
NULL
> attr(x,'names') = c('a','b','c')
> x
a b c <NA> <NA> <NA>
2 3 4 5 6
> attributes(x)
$names
[1] "a" "b" "c" NA NA NA
dim，标记对象的维度。

除向量外，基于数组的对象都会有⼀个维度属性，是⼀个指定数组各维度长度的整数向量。

与下标类似，维度也可以命名。

通过dimnames属性可以实现这⼀⽬的：
> x = array(1:6,2:3)
> x
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> attributes(x)
$dim
[1] 2 3
> names = list(c('x','y'),c('a','b','c'))
> dimnames(x) = names
> x
a b c
x 1 3 5
y 2 4 6
> attributes(x)
$dim
[1] 2 3
$dimnames
$dimnames[[1]]
[1] "x" "y"
$dimnames[[2]]
[1] "a" "b" "c"
访问对象中的元素
既然对象是元素的集合，很⾃然就会想到使⽤下标来访问对象中的元素：
> x = array(6:1,2:3)
> x
[,1] [,2] [,3]
[1,] 6 4 2
[2,] 5 3 1
> x[1] #按照存储的顺序访问单个元素
[1] 6
> x[2] #按照存储的顺序访问单个元素
[1] 5
> x[3] #按照存储的顺序访问单个元素
[1] 4
> x[1,2] #通过多个下标访问单个元素
[1] 4
> x[1,] #返回⼀⾏
[1] 6 4 2
> x[,1] #返回⼀列
[1] 6 5
如果对象有names属性，还可以通过names进⾏索引:
> x = array(6:1,2:3)
>
> names(x) = c('a','b','c')
> x
[,1] [,2] [,3]
[1,] 6 4 2
[2,] 5 3 1
attr(,"names")
[1] "a" "b" "c" NA NA NA
> x['b'] # 等价于x[2]
b
5
上⾯两个例⼦都是返回对象中的单个元素。

在R中，还可以返回对象的多个元素，此时使⽤的索引不是简单的数值或字符串，⽽是⼀个向量。

继续上⾯的例⼦：
a b c
5 4
> x[c(3,4)]
c <NA>
3
> x[c(1,2),c(1,2)]
[,1] [,2]
[1,] 6 4
[2,] 5 3
> x[c('a','b')]
a b
5
⽤序列填充对象
R中提供了⼀些创建序列的⽅法，可以很⽅便的填充对象。

包括规则序列和随机序列。

规则序列⽤于产⽣有规则的序列：
使⽤a:b的形式是最简单的⽤法;
如果需要更多的控制，可以使⽤seq(from,to,by,length,along）函数;
使⽤rep()函数可以产⽣重复的元素。

例如：
> 1:3
[1] 1 2 3
> 2*1:3
[1] 2 4 6
> 3:1
[1] 3 2 1
> seq(1,2,0.2)
[1] 1.0 1.2 1.4 1.6 1.8 2.0
> seq(1,2,0.3)
[1] 1.0 1.3 1.6 1.9
> seq(to=2,by=.2)
[1] 1.0 1.2 1.4 1.6 1.8 2.0
> seq(to=2,by=.2,length=3)
[1] 1.6 1.8 2.0
> rep(1:3,2)
[1] 1 2 3 1 2 3
> rep(1:3,each=2)
[1] 1 1 2 2 3 3
随机序列⽤于产⽣符合⼀定分布规则的数据。

有⼤量的函数⽤于产⽣随机序列，这⾥只列出⼀些函数的名称： # 随机数⽣成函数
rnorm(n, mean=0, sd=1)
typeof()函数可能返回如下的值（在R源代码src/main/util.c的TypeTable中定义）：
参考资料。