R語言學習筆記(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）。

對象的類型和長度

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, +                    cchild.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()函數可能返回如下的值（在R源代碼src/main/util.c的TypeTable中定義）：

# 數據對象
logical        含邏輯值的向量 
integer        含整數值的向量 
double        含實數值的向量 
complex        含複數值的向量 
character    含字符值的向量 
raw            含字節值的向量 

# 其他對象
list        列表 
NULL        空 
closure        函數 
special        不可針對參數求值的內置函數 
builtin        可針對參數求值的內置函數 
environment    環境 

# 通常在R內部使用
symbol        變量名 
pairlist    成對列表對象 
promise        用於實現悠閒賦值的對象 
language     R 語言構建 
...            特定變量長度參數
any            可以匹配任何類型的特殊類型
expression    表達式對象 
externalptr    外表指針對象 
weakref        弱引用對象
char            字符
bytecode        二進制

對象的類型不是一成不變的，可以隨時進行轉換。接着上面的例子：

> typeof(x) [1] "double"
> y = as.logical(x) > typeof(y) [1] "logical" 轉換的規則如下表： |----|                | to numeric                | to logical                    | to character |---+---
from numeric        -                    |0 → FALSE 其它數字 → TRUE    | 1, 2, ... → "1", "2"
from logical        FALSE → 0 TRUE → 1        |-                        | TRUE → "TRUE"   FALSE → "FALSE"
from 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>
   1    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  6 5 4
> x[c(3,4)]    c <NA>
   4    3
> x[c(1,2),c(1,2)]      [,1] [,2] [1,]    6    4 [2,]    5    3
> x[c('a','b')] a b  6 5

用序列填充對象

前面的例子中，你可能會注意到一些與python類似的語法，比如序列：

a:b

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

 

隨機序列用於產生符合一定分佈規則的數據。有大量的函數用於產生隨機序列，這裏只列出一些函數的名稱：

數據編輯器

我們當然可以使用下標操作對象，編輯對象中的數據元素。但是R提供的一個可視化的工具能夠帶來更多的便利，這就是數據編輯器。
使用data.entry()函數可以打開數據編輯器：

> x = array(6:1,2:3) > data.entry(x)

原文鏈接：http://www.cnblogs.com/holbrook/archive/2013/05/09/3068613.html