R语言—数据结构

数据集的概念

不同的行业对于数据集的行和列叫法不同。统计学家称它们为观测（observation）和变量（variable），数据库分析师则称其为记录（record）和字段（field），数据挖掘和机器学习学科的研究者则把它们叫作示例（example）和属性（attribute）。

数据结构

R拥有许多用于存储数据的对象类型，包括标量、向量、矩阵、数组、数据框和列表。它们在存储数据的类型、创建方式、结构复杂度，以及用于定位和访问其中个别元素的标记等方面均有所不同。

在R中，对象（object）是指可以赋值给变量的任何事物，包括常量、数据结构、函数，甚至图形。
从向量开始，逐个探究每一种数据结构。

向量

向量是用于存储数值型、字符型或逻辑型数据的一维数组。执行组合功能的函数c()可用来创建向量。各类向量如下例所示：

a <- c(1, 2, 5, 3, 6, -2, 4)
b <- c("one", "two", "three")
c <- c(TRUE, TRUE, TRUE, FALSE, TRUE, FALSE)
# 查看向量的类型.
print(class(a))
1
2
3
4
5

这里，a是数值型向量，b是字符型向量，而c是逻辑型向量。 注意，单个向量中的数据必须拥有相同的类型或模式（数值型、字符型或逻辑型）。同一向量中无法混杂不同模式的数据。

通过在方括号中给定元素所处位置的数值，可以访问向量中的元素。例如，a[c(2, 4)]用于访问向量a中的第二个和第四个元素。更多示例如下：

> a <- c("k", "j", "h", "a", "c", "m")
> a[3]
[1] "h"
> a[c(1, 3, 5)]
[1] "k" "h" "c"
> a[2:6]
[1] "j" "h" "a" "c" "m"
1
2
3
4
5
6
7

最后一个语句中使用的冒号用于生成一个数值序列。例如，a <- c(2:6)等价于a <- c(2,3, 4, 5, 6)。

标量

R中没有标量，可将“标量”理解为只含一个元素的向量，例如f <- 3、g <- "US"和h <- TRUE。它们用于保存常量。

矩阵

矩阵是一个二维数组，只是每个元素都拥有相同的模式（数值型、字符型或逻辑型）。可通过函数matrix()创建矩阵。一般使用格式为：

myymatrix <- matrix(vector, nrow=number_of_rows, ncol=number_of_columns,byrow=logical_value, dimnames=list(char_vector_rownames, char_vector_colnames))
1

其中vector包含了矩阵的元素，nrow和ncol用以指定行和列的维数，dimnames包含了可选
的、以字符型向量表示的行名和列名。选项byrow则表明矩阵应当按行填充（byrow=TRUE）
还是按列填充（byrow=FALSE），默认情况下按列填充。

创建了一个5×4的矩阵，接着创建了一个2×2的含列名标签的矩阵，并按行进行填充，最后创建了一个2×2的矩阵并按列进行了填充。

> y <- matrix(1:20, nrow=5, ncol=4)
> y
[,1] [,2] [,3] [,4]
[1,] 1 6 11 16
[2,] 2 7 12 17
[3,] 3 8 13 18
[4,] 4 9 14 19
[5,] 5 10 15 20
> cells <- c(1,26,24,68)
> rnames <- c("R1", "R2")
> cnames <- c("C1", "C2")
> mymatrix <- matrix(cells, nrow=2, ncol=2, byrow=TRUE,
dimnames=list(rnames, cnames))
> mymatrix
C1 C2
R1 1 26
R2 24 68
> mymatrix <- matrix(cells, nrow=2, ncol=2, byrow=FALSE,
dimnames=list(rnames, cnames))
> mymatrix
C1 C2
R1 1 24
R2 26 68
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

可以使用下标和方括号来选择矩阵中的行、列或元素。X[i,]指矩阵X中的第i行，X[,j]指第j列，X[i, j]指第i行第j 个元素。选择多行或多列时，下标i和j可为数值型向量。矩阵下标的使用：

创建了一个内容为数字1到10的2×5矩阵。默认情况下，矩阵按列填充。然后，分别选择了第二行和第二列的元素。接着，又选择了第一行第四列的元素。最后选择了位于第一行第四、第五列的元素。矩阵都是二维的，和向量类似，矩阵中也仅能包含一种数据类型。

> x <- matrix(1:10, nrow=2)
> x
[,1] [,2] [,3] [,4] [,5]
[1,] 1 3 5 7 9
[2,] 2 4 6 8 10
> x[2,]
[1] 2 4 6 8 10
> x[,2]
[1] 3 4
> x[1,4]
[1] 7
> x[1, c(4,5)]
[1] 7 9
1
2
3
4
5
6
7
8
9
10
11
12
13

数组

数组（array）与矩阵类似，但是维度可以大于2。数组可通过array函数创建，形式如下：

myarray <- array(vector, dimensions, dimnames)
1

其中vector包含了数组中的数据，dimensions是一个数值型向量，给出了各个维度下标的最大值，而dimnames是可选的、各维度名称标签的列表。创建一个三维（2×3×4）数值型数组：

> dim1 <- c("A1", "A2")
> dim2 <- c("B1", "B2", "B3")
> dim3 <- c("C1", "C2", "C3", "C4")
> z <- array(1:24, c(2, 3, 4), dimnames=list(dim1, dim2, dim3))
> z
, , C1
B1 B2 B3
A1 1 3 5
A2 2 4 6
, , C2
B1 B2 B3
A1 7 9 11
A2 8 10 12
, , C3
B1 B2 B3
A1 13 15 17
A2 14 16 18
, , C4
B1 B2 B3
A1 19 21 23
A2 20 22 24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

数组是矩阵的一个自然推广。它们在编写新的统计方法时可能很有用。像矩阵一样，数组中的数据也只能拥有一种模式。从数组中选取元素的方式与矩阵相同。上例中，元素z[1,2,3]为15。

数据框

由于不同的列可以包含不同模式（数值型、字符型等）的数据，数据框的概念较矩阵来说更为一般。它与SAS、SPSS和Stata中看到的数据集类似。数据框将是R中最常处理的数据结构。数据框可通过函数data.frame()创建：

mydata <- data.frame(col1, col2, col3,...)
1

其中的列向量col1、col2、col3等可为任何类型（如字符型、数值型或逻辑型）。每一列的名
称可由函数names指定。创建一个数据框：

> patientID <- c(1, 2, 3, 4)
> age <- c(25, 34, 28, 52)
> diabetes <- c("Type1", "Type2", "Type1", "Type1")
> status <- c("Poor", "Improved", "Excellent", "Poor")
> patientdata <- data.frame(patientID, age, diabetes, status)
> patientdata
patientID age diabetes status
1 1 25 Type1 Poor
2 2 34 Type2 Improved
3 3 28 Type1 Excellent
4 4 52 Type1 Poor
1
2
3
4
5
6
7
8
9
10
11

每一列数据的模式必须唯一，不过却可以将多个模式的不同列放到一起组成数据框。由于数据框与分析人员通常设想的数据集的形态较为接近，在讨论数据框时将交替使用术语列和变量。
选取数据框中元素的方式有若干种。可以使用前述（如矩阵中的）下标记号，亦可直接指定列名。
选取数据框中的元素

> patientdata[1:2]
patientID age
1 1 25
2 2 34
3 3 28
4 4 52
> patientdata[c("diabetes", "status")]
diabetes status
1 Type1 Poor
2 Type2 Improved
3 Type1 Excellent
4 Type1 Poor
> patientdata$age
[1] 25 34 28 52
1
2
3
4
5
6
7
8
9
10
11
12
13
14

例子中的记号$是新出现的。它被用来选取一个给定数据框中的某个特定变量。例如，如果想生成糖尿病类型变量diabetes和病情变量status的列联表，使用以下代码即可：

> table(patientdata$diabetes, patientdata$status)
Excellent Improved Poor
Type1 1 0 2
Type2 0 1 0
1
2
3
4

在每个变量名前都键入一次patientdata$可能会让人生厌，所以不妨走一些捷径。可以联合使用函数attach()和detach()或单独使用函数with()来简化代码。

attach()

函数attach()可将数据框添加到R的搜索路径中。R在遇到一个变量名以后，将检查搜索路径中的数据框。

summary(mtcars$mpg)
plot(mtcars$mpg, mtcars$disp)
plot(mtcars$mpg, mtcars$wt)
1
2
3

以上代码也可写成：

attach(mtcars)
summary(mpg)
plot(mpg, disp)
plot(mpg, wt)
detach(mtcars)
1
2
3
4
5

函数detach()将数据框从搜索路径中移除。值得注意的是，detach()并不会对数据框本身做任何处理。这句是可以省略的，但其实它应当被例行地放入代码中，因为这是一个好的编程习惯。当名称相同的对象不止一个时，这种方法的局限性就很明显了。考虑以下代码：

> mpg <- c(25, 36, 47)
> attach(mtcars)
The following object(s) are masked _by_ '.GlobalEnv': mpg
> plot(mpg, wt)
Error in xy.coords(x, y, xlabel, ylabel, log) :
'x' and 'y' lengths differ
> mpg
[1] 25 36 47
1
2
3
4
5
6
7
8

这里，在数据框mtcars被绑定（attach）之前，你们的环境中已经有了一个名为mpg的对象。在这种情况下，原始对象将取得优先权，这与你们想要的结果有所出入。函数attach()和detach()最好在你分析一个单独的数据框，并且不太可能有多个同名对象时使用。任何情况下，都要当心那些告知某个对象已被屏蔽（masked）的警告。

with()

除此之外，另一种方式是使用函数with()。可以这样重写上例：

with(mtcars, {
print(summary(mpg))
plot(mpg, disp)
plot(mpg, wt)
})
1
2
3
4
5

在这种情况下，花括号{}之间的语句都针对数据框mtcars执行，这样就无需担心名称冲突了。
函数with()的局限性在于，赋值仅在此函数的括号内生效。考虑以下代码：

> with(mtcars, {
stats <- summary(mpg)
stats
})
Min. 1st Qu. Median Mean 3rd Qu. Max.
10.40 15.43 19.20 20.09 22.80 33.90
> stats
Error: object 'stats' not found
1
2
3
4
5
6
7
8

如果你需要创建在with()结构以外存在的对象，使用特殊赋值符<<-替代标准赋值符（<-）即可，它可将对象保存到with()之外的全局环境中。这一点可通过以下代码阐明：

> with(mtcars, {
nokeepstats <- summary(mpg)
keepstats <<- summary(mpg)
})
> nokeepstats
Error: object 'nokeepstats' not found
> keepstats
Min. 1st Qu. Median Mean 3rd Qu. Max.
10.40 15.43 19.20 20.09 22.80 33.90
1
2
3
4
5
6
7
8
9

相对于attach()，多数的R书籍更推荐使用with()。个人认为从根本上说，选择哪一个是自己的偏好问题，并且应当根据你的目的和对于这两个函数含义的理解而定。

因子

变量可归结为名义型、有序型或连续型变量。
名义型变量是没有顺序之分的类别变量。糖尿病类型Diabetes（Type1、Type2）是名义型变量的一例。即使在数据中Type1编码为1而Type2编码为2，这也并不意味着二者是有序的。
有序型变量表示一种顺序关系，而非数量关系。病情Status（poor、improved、excellent）是顺序型变量的一个上佳示例。病情为poor（较差）病人的状态不如improved（病情好转）的病人，但并不知道相差多少。
连续型变量可以呈现为某个范围内的任意值，并同时表示了顺序和数量。年龄Age就是一个连续型变量，它能够表示像14.5或22.8这样的值以及其间的其他任意值。很清楚，15岁的人比14岁的人年长一岁。
类别（名义型）变量和有序类别（有序型）变量在R中称为因子（factor）。因子在R中非常重要，因为它决定了数据的分析方式以及如何进行视觉呈现。函数factor()以一个整数向量的形式存储类别值，整数的取值范围是[1…k]（其中k是名义型变量中唯一值的个数），同时一个由字符串（原始值）组成的内部向量将映射到这些整数上。
举例来说，假设有向量：

diabetes <- c("Type1", "Type2", "Type1", "Type1")
1

语句diabetes <- factor(diabetes)将此向量存储为(1, 2, 1, 1)，并在内部将其关联为1=Type1和2=Type2（具体赋值根据字母顺序而定）。针对向量diabetes进行的任何分析都会将其作为名义型变量对待，并自动选择适合这一测量尺度的统计方法。
要表示有序型变量，需要为函数factor()指定参数ordered=TRUE。给定向量：

status <- c("Poor", "Improved", "Excellent", "Poor")
1

语句status <- factor(status, ordered=TRUE)会将向量编码为(3, 2, 1, 3)，并在内部将这些值关联为1=Excellent、2=Improved以及3=Poor。另外，针对此向量进行的任何分析都会将其作为有序型变量对待，并自动选择合适的统计方法。
对于字符型向量，因子的水平默认依字母顺序创建。这对于因子status是有意义的，因为“Excellent”“Improved”“Poor”的排序方式恰好与逻辑顺序相一致。如果“Poor”被编码为“Ailing”，会有问题，因为顺序将为“Ailing”“Excellent”“Improved”。如果理想中的顺序是“Poor”“Improved”“Excellent”，则会出现类似的问题。按默认的字母顺序排序的因子很少能够让人满意。可以通过指定levels选项来覆盖默认排序。例如：

status <- factor(status, order=TRUE,levels=c("Poor", "Improved", "Excellent"))
1

各水平的赋值将为1=Poor、2=Improved、3=Excellent。请保证指定的水平与数据中的真实值相匹配，因为任何在数据中出现而未在参数中列举的数据都将被设为缺失值。
数值型变量可以用levels和labels参数来编码成因子。如果男性被编码成1，女性被编码成2，则以下语句：

sex <- factor(sex, levels=c(1, 2), labels=c("Male", "Female"))
1

把变量转换成一个无序因子。注意到标签的顺序必须和水平相一致。在这个例子中，性别将被当成类别型变量，标签“Male”和“Female”将替代1和2在结果中输出，而且所有不是1或2的性别变量将被设为缺失值。因子的使用：

> patientID <- c(1, 2, 3, 4)
> age <- c(25, 34, 28, 52)
> diabetes <- c("Type1", "Type2", "Type1", "Type1")
> status <- c("Poor", "Improved", "Excellent", "Poor")
> diabetes <- factor(diabetes)
> status <- factor(status, order=TRUE)
> patientdata <- data.frame(patientID, age, diabetes, status)
> str(patientdata)
‘data.frame’: 4 obs. of 4 variables:
$ patientID: num 1 2 3 4
$ age : num 25 34 28 52
$ diabetes : Factor w/ 2 levels "Type1","Type2": 1 2 1 1
$ status : Ord.factor w/ 3 levels "Excellent"<"Improved"<..: 3 2 1 3
> summary(patientdata)
patientID age diabetes status
Min. :1.00 Min. :25.00 Type1:3 Excellent:1
1st Qu.:1.75 1st Qu.:27.25 Type2:1 Improved :1
Median :2.50 Median :31.00 Poor :2
Mean :2.50 Mean :34.75
3rd Qu.:3.25 3rd Qu.:38.50
Max. :4.00 Max. :52.00
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

首先，以向量的形式输入数据。然后，将diabetes和status分别指定为一个普通因子和一个有序型因子。最后，将数据合并为一个数据框。函数str(object)可提供R中某个对象（本例中为数据框）的信息。它清楚地显示diabetes是一个因子，而status是一个有序型因子，以及此数据框在内部是如何进行编码的。注意，函数summary()会区别对待各个变量。它显示了连续型变量age的最小值、最大值、均值和各四分位数，并显示了类别型变量diabetes和status（各水平）的频数值。

列表

列表（list）是R的数据类型中最为复杂的一种。一般来说，列表就是一些对象（或成分，component）的有序集合。列表允许整合若干（可能无关的）对象到单个对象名下。例如，某个列表中可能是若干向量、矩阵、数据框，甚至其他列表的组合。可以使用函数list()创建列表：

mylist <- list(object1, object2, ...)
1

其中的对象可以是目前为止讲到的任何结构。还可以为列表中的对象命名：

mylist <- list(name1=object1, name2=object2, ...)
1

> g <- "My First List"
> h <- c(25, 26, 18, 39)
> j <- matrix(1:10, nrow=5)
> k <- c("one", "two", "three")
> mylist <- list(title=g, ages=h, j, k)
> mylist
$title
[1] "My First List"
$ages
[1] 25 26 18 39
[[3]]
[,1] [,2]
[1,] 1 6
[2,] 2 7
[3,] 3 8
[4,] 4 9
[5,] 5 10
[[4]]
[1] "one" "two" "three"
> mylist[[2]]
[1] 25 26 18 39
> mylist[["ages"]]
[[1] 25 26 18 39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

本例创建了一个列表，其中有四个成分：一个字符串、一个数值型向量、一个矩阵以及一个字符型向量。可以组合任意多的对象，并将它们保存为一个列表。也可以通过在双重方括号中指明代表某个成分的数字或名称来访问列表中的元素。此例中，mylist[[2]]和mylist[[“ages”]]均指那个含有四个元素的向量。对于命名成分，mylist$ages也可以正常运行。由于两个原因，列表成为了R中的重要数据结构。首先，列表允许以一种简单的方式组织和重新调用不相干的信息。其次，许多R函数的运行结果都是以列表的形式返回的。需要取出其中哪些成分由分析人员决定。

R语言的某些方面不太寻常。这门语言中需要注意的一些特性

❑对象名称中的句点（.）没有特殊意义，但美元符号（$）却有着和其他语言中的句点类似的含义，即指定一个数据框或列表中的某些部分。例如，A$x是指数据框A中的变量x。
❑R不提供多行注释或块注释功能。你必须以#作为多行注释每行的开始。出于调试目的，你也可以把想让解释器忽略的代码放到语句if(FALSE){… }中。将FALSE改为TRUE即允许这块代码执行。
❑将一个值赋给某个向量、矩阵、数组或列表中一个不存在的元素时，R将自动扩展这个数据结构以容纳新值。举例来说，考虑以下代码：

> x <- c(8, 6, 4)
> x[7] <- 10
> x
[1] 8 6 4 NA NA NA 10
1
2
3
4

通过赋值，向量x由三个元素扩展到了七个元素。x <- x[1:3]会重新将其缩减回三个元素。
❑R中没有标量。标量以单元素向量的形式出现。
❑R中的下标不从0开始，而从1开始。在上述向量中，x[1]的值为8。
❑变量无法被声明。它们在首次被赋值时生成。

处理数据的常用函数

length(object) 
# 显示对象中元素/成分的数量
dim(object)     
# 显示某个对象的维度
str(object)     
# 显示某个对象的结构
class(object)     
# 显示某个对象的类或类型
mode(object)     
# 显示某个对象的模式
names(object)     
# 显示某对象中各成分的名称
c(object, object,…)     
# 将对象合并入一个向量
cbind(object, object, …) 
# 按列合并对象
rbind(object, object, …) 
# 按行合并对象
Object 
# 输出某个对象
head(object) 
# 列出某个对象的开始部分
tail(object) 
# 列出某个对象的最后部分
ls() 
# 显示当前的对象列表
rm(object, object, …) 
# 删除一个或更多个对象。语句rm(list = ls())将删除当前工作环境中的几乎所有对象,以句点.开头的隐藏对象将不受影响
newobject <- edit(object) 
# 编辑对象并另存为newobject
fix(object) 
# 直接编辑对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32