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            含字節(jié)值的向量 

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

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

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

> typeof(x) [1] "double" 
> y = as.logical(x) > typeof(y) [1] "logical" 轉換的規(guī)則如下表： |----|                | 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 |  

對象的長度也可以隨時發(fā)生改變，常見的包括如下情況：

> # 擴大索引范圍 
> 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屬性可以實現(xiàn)這一目的：

> 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ù)上面的例子：

> 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中提供了一些創(chuàng)建序列的方法，可以很方便的填充對象。包括規(guī)則序列和隨機序列。

規(guī)則序列用于產生有規(guī)則的序列:

使用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 

隨機序列用于產生符合一定分布規(guī)則的數據。有大量的函數用于產生隨機序列，這里只列出一些函數的名稱：

數據編輯器

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

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

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

【編輯推薦】

1.R語言學習筆記(1)：R是什么