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()
	is.complex()
	is.character()

  强制转换

	as.logical()
	as.numeric()
	-- as.integer()
	-- as.double()
	-- as.factor()
	as.complex()
	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( )可获取对象的存储模式。
	typeof( )获取数据的类型或存储模式。
	要了解这些函数能干什么可以在R里面查询，方法是用问号加上面的函数名就可以，如：?str

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 numeric	-	0 → FALSE | 其它数字 → TRUE	1, 2, ... → "1", "2"
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
	> x
	[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中，还可以返回对象的多个元素，此时使用的索引不是简单的数值或字符串，而是一个向量。继续上面的例子：

	> x[1:3]
	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中定义）：

参考资料

• R语言 笔记 对象类型/属性 mode()

• R中的数据类型和数据结构

• R数据类型与对象

• R数据类型与对象