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中定義）：